Changeset 7a70fb2


Ignore:
Timestamp:
Dec 17, 2020, 10:34:27 AM (9 months ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
arm-eh, jacob/cs343-translation, master, new-ast-unique-expr
Children:
852ae0ea
Parents:
72a3aff (diff), 28e88d7 (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' of plg.uwaterloo.ca:software/cfa/cfa-cc

Files:
3 deleted
59 edited

Legend:

Unmodified
Added
Removed
  • libcfa/src/bits/collection.hfa

    r72a3aff r7a70fb2  
    11#pragma once
     2#include <stdio.h> // REMOVE THIS AFTER DEBUGGING
     3
    24
    35struct Colable {
    4         Colable * next;                                                                         // next node in the list
     6        struct Colable * next;                                                                          // next node in the list
    57        // invariant: (next != 0) <=> listed()
    68};
    7 
    8 inline {
     9#ifdef __cforall
     10static inline {
    911        // PUBLIC
    1012
     
    2830        }
    2931
    30         // wrappers to make Collection have T
    31         forall( dtype T ) {
    32                 T *& Next( T * n ) {
    33                         return (T *)Next( (Colable *)n );
    34                 }
     32        // // wrappers to make Collection have T
     33        // forall( dtype T ) {
     34        //      T *& Next( T * n ) {
     35        //              return (T *)Next( (Colable *)n );
     36        //      }
    3537
    36                 bool listed( T * n ) {
    37                         return Next( (Colable *)n ) != 0p;
    38                 }
    39         } // distribution
     38        //      bool listed( T * n ) {
     39        //              return Next( (Colable *)n ) != 0p;
     40        //      }
     41        // } // distribution
    4042} // distribution
    4143
     
    4547};
    4648
    47 inline {
     49static inline {
    4850        // class invariant: root == 0 & empty() | *root in *this
    4951        void ?{}( Collection &, const Collection & ) = void; // no copy
     
    6870};
    6971
    70 inline {
     72static inline {
    7173        void ?{}( ColIter & colIter ) with( colIter ) {
    7274                curr = 0p;
     
    7981        } // distribution
    8082} // distribution
     83#endif
  • libcfa/src/bits/containers.hfa

    r72a3aff r7a70fb2  
    3636        #define __small_array_t(T) __small_array(T)
    3737#else
    38         #define __small_array_t(T) struct __small_array
     38        #define __small_array_t(T) __small_array
    3939#endif
    4040
  • libcfa/src/bits/defs.hfa

    r72a3aff r7a70fb2  
    2929#define __cfa_anonymous_object(x) inline struct x
    3030#else
    31 #define __cfa_anonymous_object(x) x __cfa_anonymous_object
     31#define __cfa_anonymous_object(x) struct x __cfa_anonymous_object
    3232#endif
    3333
  • libcfa/src/bits/queue.hfa

    r72a3aff r7a70fb2  
    33#include "bits/collection.hfa"
    44
    5 forall( dtype T ) {
     5forall( dtype T | { T *& Next ( T * ); bool listed ( T * ); } ) {
    66        struct Queue {
    77                inline Collection;                                                              // Plan 9 inheritance
     
    6464                        T & t = head( q );
    6565                        if ( root ) {
    66                                 root = Next( root );
     66                                root = Next( (T *)root );
    6767                                if ( &head( q ) == &t ) {
    6868                                        root = last = 0p;                                       // only one element
     
    142142} // distribution
    143143
    144 forall( dtype T ) {
     144forall( dtype T | { T *& Next ( T * ); bool listed ( T * ); } ) {
    145145        struct QueueIter {
    146146                inline ColIter;                                                                 // Plan 9 inheritance
  • libcfa/src/bits/sequence.hfa

    r72a3aff r7a70fb2  
    22
    33#include "bits/collection.hfa"
     4#include "bits/defs.hfa"
    45
    56struct Seqable {
    6         inline Colable;
    7         Seqable * back;                                                                         // pointer to previous node in the list
     7        __cfa_anonymous_object(Colable);
     8        struct Seqable * back;                                                                          // pointer to previous node in the list
    89};
    910
    10 inline {
     11#ifdef __cforall
     12static inline {
    1113        // PUBLIC
    1214
     
    2628        }
    2729
    28         // wrappers to make Collection have T
    29         forall( dtype T ) {
    30                 T *& Back( T * n ) {
    31                         return (T *)Back( (Seqable *)n );
    32                 }
    33         } // distribution
     30        // // wrappers to make Collection have T
     31        // forall( dtype T ) {
     32        //      T *& Back( T * n ) {
     33        //              return (T *)Back( (Seqable *)n );
     34        //      }
     35        // } // distribution
    3436} // distribution
    3537
    36 forall( dtype T ) {
     38forall( dtype T | { T *& Back ( T * ); T *& Next ( T * ); bool listed ( T * ); } ) {
    3739        struct Sequence {
    3840                inline Collection;                                                              // Plan 9 inheritance
    3941        };
    4042
    41         inline {
     43        static inline {
    4244                // wrappers to make Collection have T
    4345                T & head( Sequence(T) & s ) with( s ) {
     
    184186                                T * toEnd = Back( &head( s ) );
    185187                                T * fromEnd = Back( &head( from ) );
    186                                 Back( root ) = fromEnd;
     188                                Back( (T *)root ) = fromEnd;
    187189                                Next( fromEnd ) = &head( s );
    188                                 Back( from.root ) = toEnd;
     190                                Back( (T *)from.root ) = toEnd;
    189191                                Next( toEnd ) = &head( from );
    190192                        } // if
     
    214216} // distribution
    215217
    216 forall( dtype T ) {
     218forall( dtype T | { T *& Back ( T * ); T *& Next ( T * ); bool listed ( T * ); } ) {
    217219        // SeqIter(T) is used to iterate over a Sequence(T) in head-to-tail order.
    218220        struct SeqIter {
     
    224226        };
    225227
    226         inline {
     228        static inline {
    227229                void ?{}( SeqIter(T) & si ) with( si ) {
    228230                        ((ColIter &)si){};
     
    265267        };
    266268
    267         inline {
     269        static inline {
    268270                void ?{}( SeqIterRev(T) & si ) with( si ) {     
    269271                        ((ColIter &)si){};
     
    298300        } // distribution
    299301} // distribution
     302
     303#endif
  • libcfa/src/bits/stack.hfa

    r72a3aff r7a70fb2  
    33#include "bits/collection.hfa"
    44
    5 forall( dtype T ) {
     5forall( dtype T | { T *& Next ( T * ); bool listed ( T * ); } ) {
    66        struct Stack {
    77                inline Collection;                                                              // Plan 9 inheritance
     
    4444                        T & t = head( s );
    4545                        if ( root ) {
    46                                 root = ( T *)Next( root );
     46                                root = ( T *)Next( (T *)root );
    4747                                if ( &head( s ) == &t ) root = 0p;              // only one element ?
    4848                                Next( &t ) = 0p;
     
    5858
    5959
    60 forall( dtype T ) {
     60forall( dtype T | { T *& Next ( T * ); bool listed ( T * ); } ) {
    6161        struct StackIter {
    6262                inline ColIter;                                                                 // Plan 9 inheritance
  • libcfa/src/concurrency/coroutine.cfa

    r72a3aff r7a70fb2  
    1010// Created On       : Mon Nov 28 12:27:26 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Oct 23 23:05:24 2020
    13 // Update Count     : 22
     12// Last Modified On : Tue Dec 15 12:06:04 2020
     13// Update Count     : 23
    1414//
    1515
     
    8888static const size_t MinStackSize = 1000;
    8989extern size_t __page_size;                              // architecture pagesize HACK, should go in proper runtime singleton
     90extern int __map_prot;
    9091
    9192void __stack_prepare( __stack_info_t * this, size_t create_size );
     
    206207                __cfaabi_dbg_debug_do(
    207208                        storage = (char*)(storage) - __page_size;
    208                         if ( mprotect( storage, __page_size, PROT_READ | PROT_WRITE ) == -1 ) {
     209                        if ( mprotect( storage, __page_size, __map_prot ) == -1 ) {
    209210                                abort( "(coStack_t *)%p.^?{}() : internal error, mprotect failure, error(%d) %s.", &this, errno, strerror( errno ) );
    210211                        }
  • libcfa/src/concurrency/invoke.h

    r72a3aff r7a70fb2  
    189189                struct __monitor_group_t monitors;
    190190
     191                // used to put threads on user data structures
     192                struct {
     193                        struct $thread * next;
     194                        struct $thread * back;
     195                } seqable;
     196
    191197                struct {
    192198                        struct $thread * next;
     
    218224                }
    219225
     226                static inline $thread *& Back( $thread * this ) __attribute__((const)) {
     227                        return this->seqable.back;
     228                }
     229
     230                static inline $thread *& Next( $thread * this ) __attribute__((const)) {
     231                        return this->seqable.next;
     232                }
     233
     234                static inline bool listed( $thread * this ) {
     235                        return this->seqable.next != 0p;
     236                }
     237
    220238                static inline void ?{}(__monitor_group_t & this) {
    221239                        (this.data){0p};
  • libcfa/src/concurrency/kernel/startup.cfa

    r72a3aff r7a70fb2  
    117117}
    118118
    119 size_t __page_size = 0;
     119extern size_t __page_size;
    120120
    121121//-----------------------------------------------------------------------------
     
    161161        /* paranoid */ verify( ! __preemption_enabled() );
    162162        __cfadbg_print_safe(runtime_core, "Kernel : Starting\n");
    163 
    164         __page_size = sysconf( _SC_PAGESIZE );
    165163
    166164        __cfa_dbg_global_clusters.list{ __get };
     
    681679        #if CFA_PROCESSOR_USE_MMAP
    682680                stacksize = ceiling( stacksize, __page_size ) + __page_size;
    683                 stack = mmap(0p, stacksize, PROT_EXEC | PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
     681                stack = mmap(0p, stacksize, __map_prot, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
    684682                if(stack == ((void*)-1)) {
    685683                        abort( "pthread stack creation : internal error, mmap failure, error(%d) %s.", errno, strerror( errno ) );
  • libcfa/src/concurrency/locks.cfa

    r72a3aff r7a70fb2  
    2929
    3030        void ^?{}( info_thread(L) & this ){ }
     31
     32        info_thread(L) *& Back( info_thread(L) * this ) {
     33                return (info_thread(L) *)Back( (Seqable *)this );
     34        }
     35
     36        info_thread(L) *& Next( info_thread(L) * this ) {
     37                return (info_thread(L) *)Next( (Colable *)this );
     38        }
     39
     40        bool listed( info_thread(L) * this ) {
     41                return Next( (Colable *)this ) != 0p;
     42        }
    3143}
    3244
     
    5870                abort("A single acquisition lock holder attempted to reacquire the lock resulting in a deadlock.");
    5971        } else if ( owner != 0p && owner != active_thread() ) {
    60                 append( blocked_threads, active_thread() );
     72                addTail( blocked_threads, *active_thread() );
    6173                wait_count++;
    6274                unlock( lock );
     
    96108
    97109void pop_and_set_new_owner( blocking_lock & this ) with( this ) {
    98         $thread * t = pop_head( blocked_threads );
     110        $thread * t = &dropHead( blocked_threads );
    99111        owner = t;
    100112        recursion_count = ( t ? 1 : 0 );
     
    128140    lock( lock __cfaabi_dbg_ctx2 );
    129141        if ( owner != 0p ) {
    130                 append( blocked_threads, t );
     142                addTail( blocked_threads, *t );
    131143                wait_count++;
    132144                unlock( lock );
     
    257269                size_t recursion_count = 0;
    258270                if (i->lock) {
    259                         i->t->link.next = 1p;
    260271                        recursion_count = get_recursion_count(*i->lock);
    261272                        remove_( *i->lock );
  • libcfa/src/concurrency/locks.hfa

    r72a3aff r7a70fb2  
    4343        void ?{}( info_thread(L) & this, $thread * t, uintptr_t info );
    4444        void ^?{}( info_thread(L) & this );
     45
     46        info_thread(L) *& Back( info_thread(L) * this );
     47        info_thread(L) *& Next( info_thread(L) * this );
     48        bool listed( info_thread(L) * this );
    4549}
    4650
     
    6468
    6569        // List of blocked threads
    66         __queue_t( $thread ) blocked_threads;
     70        Sequence( $thread ) blocked_threads;
    6771
    6872        // Count of current blocked threads
  • libcfa/src/concurrency/thread.cfa

    r72a3aff r7a70fb2  
    4343                canary = 0x0D15EA5E0D15EA5Ep;
    4444        #endif
     45
     46        seqable.next = 0p;
     47        seqable.back = 0p;
    4548
    4649        node.next = 0p;
  • libcfa/src/heap.cfa

    r72a3aff r7a70fb2  
    1010// Created On       : Tue Dec 19 21:58:35 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Dec 13 22:04:10 2020
    13 // Update Count     : 984
     12// Last Modified On : Wed Dec 16 12:28:25 2020
     13// Update Count     : 1023
    1414//
    1515
    1616#include <unistd.h>                                                                             // sbrk, sysconf
     17#include <stdlib.h>                                                                             // EXIT_FAILURE
    1718#include <stdbool.h>                                                                    // true, false
    1819#include <stdio.h>                                                                              // snprintf, fileno
     
    7172        // Define the default extension heap amount in units of bytes. When the uC++ supplied heap reaches the brk address,
    7273        // the brk address is extended by the extension amount.
    73         __CFA_DEFAULT_HEAP_EXPANSION__ = (1 * 1024 * 1024),
     74        __CFA_DEFAULT_HEAP_EXPANSION__ = (10 * 1024 * 1024),
    7475
    7576        // Define the mmap crossover point during allocation. Allocations less than this amount are allocated from buckets;
     
    115116
    116117// statically allocated variables => zero filled.
    117 static size_t pageSize;                                                                 // architecture pagesize
     118size_t __page_size;                                                                             // architecture pagesize
     119int __map_prot;                                                                                 // common mmap/mprotect protection
    118120static size_t heapExpand;                                                               // sbrk advance
    119121static size_t mmapStart;                                                                // cross over point for mmap
     
    249251#endif // FASTLOOKUP
    250252
    251 static int mmapFd = -1;                                                                 // fake or actual fd for anonymous file
     253static const off_t mmapFd = -1;                                                 // fake or actual fd for anonymous file
    252254#ifdef __CFA_DEBUG__
    253255static bool heapBoot = 0;                                                               // detect recursion during boot
     
    374376
    375377static inline bool setMmapStart( size_t value ) {               // true => mmapped, false => sbrk
    376   if ( value < pageSize || bucketSizes[NoBucketSizes - 1] < value ) return false;
     378  if ( value < __page_size || bucketSizes[NoBucketSizes - 1] < value ) return false;
    377379        mmapStart = value;                                                                      // set global
    378380
     
    436438        header = headerAddr( addr );
    437439
    438   if ( unlikely( heapEnd < addr ) ) {                                   // mmapped ?
     440  if ( unlikely( addr < heapBegin || heapEnd < addr ) ) { // mmapped ?
    439441                fakeHeader( header, alignment );
    440442                size = header->kind.real.blockSize & -3;                // mmap size
     
    443445
    444446        #ifdef __CFA_DEBUG__
    445         checkHeader( addr < heapBegin, name, addr );            // bad low address ?
     447        checkHeader( header < (HeapManager.Storage.Header *)heapBegin, name, addr ); // bad low address ?
    446448        #endif // __CFA_DEBUG__
    447449
     
    482484#endif // __CFA_DEBUG__
    483485
     486
    484487#define NO_MEMORY_MSG "insufficient heap memory available for allocating %zd new bytes."
    485488
     
    490493                // If the size requested is bigger than the current remaining storage, increase the size of the heap.
    491494
    492                 size_t increase = ceiling2( size > heapExpand ? size : heapExpand, pageSize );
     495                size_t increase = ceiling2( size > heapExpand ? size : heapExpand, __page_size );
     496                // Do not call abort or strerror( errno ) as they may call malloc.
    493497                if ( sbrk( increase ) == (void *)-1 ) {                 // failed, no memory ?
    494498                        unlock( extlock );
    495                         abort( NO_MEMORY_MSG, size );                           // give up
    496                 } // if
    497                 if ( mprotect( (char *)heapEnd + heapRemaining, increase, PROT_READ | PROT_WRITE | PROT_EXEC ) ) {
    498                         enum { BufferSize = 128 };
    499                         char helpText[BufferSize];
    500                         // Do not call strerror( errno ) as it may call malloc.
    501                         int len = snprintf( helpText, BufferSize, "internal error, extend(), mprotect failure, heapEnd:%p size:%zd, errno:%d.", heapEnd, increase, errno );
    502                         __cfaabi_bits_write( STDERR_FILENO, helpText, len );
     499                        __cfaabi_bits_print_nolock( STDERR_FILENO, NO_MEMORY_MSG, size );
     500                        _exit( EXIT_FAILURE );
     501                } // if
     502                if ( mprotect( (char *)heapEnd + heapRemaining, increase, __map_prot ) ) {
     503                        unlock( extlock );
     504                        __cfaabi_bits_print_nolock( STDERR_FILENO, "extend() : internal error, mprotect failure, heapEnd:%p size:%zd, errno:%d.\n", heapEnd, increase, errno );
     505                        _exit( EXIT_FAILURE );
    503506                } // if
    504507                #ifdef __STATISTICS__
     
    508511                #ifdef __CFA_DEBUG__
    509512                // Set new memory to garbage so subsequent uninitialized usages might fail.
    510                 //memset( (char *)heapEnd + heapRemaining, '\377', increase );
    511                 Memset( (char *)heapEnd + heapRemaining, increase );
     513                memset( (char *)heapEnd + heapRemaining, '\xde', increase );
     514                //Memset( (char *)heapEnd + heapRemaining, increase );
    512515                #endif // __CFA_DEBUG__
    513516                rem = heapRemaining + increase - size;
     
    568571                block->header.kind.real.home = freeElem;                // pointer back to free list of apropriate size
    569572        } else {                                                                                        // large size => mmap
    570   if ( unlikely( size > ULONG_MAX - pageSize ) ) return 0p;
    571                 tsize = ceiling2( tsize, pageSize );                    // must be multiple of page size
     573  if ( unlikely( size > ULONG_MAX - __page_size ) ) return 0p;
     574                tsize = ceiling2( tsize, __page_size );                 // must be multiple of page size
    572575                #ifdef __STATISTICS__
    573576                __atomic_add_fetch( &mmap_calls, 1, __ATOMIC_SEQ_CST );
     
    575578                #endif // __STATISTICS__
    576579
    577                 block = (HeapManager.Storage *)mmap( 0, tsize, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE | MAP_ANONYMOUS, mmapFd, 0 );
     580                block = (HeapManager.Storage *)mmap( 0, tsize, __map_prot, MAP_PRIVATE | MAP_ANONYMOUS, mmapFd, 0 );
    578581                if ( block == (HeapManager.Storage *)MAP_FAILED ) { // failed ?
    579582                        if ( errno == ENOMEM ) abort( NO_MEMORY_MSG, tsize ); // no memory
     
    583586                #ifdef __CFA_DEBUG__
    584587                // Set new memory to garbage so subsequent uninitialized usages might fail.
    585                 //memset( block, '\377', tsize );
    586                 Memset( block, tsize );
     588                memset( block, '\xde', tsize );
     589                //Memset( block, tsize );
    587590                #endif // __CFA_DEBUG__
    588591                block->header.kind.real.blockSize = tsize;              // storage size for munmap
     
    624627                #endif // __STATISTICS__
    625628                if ( munmap( header, size ) == -1 ) {
    626                         #ifdef __CFA_DEBUG__
    627629                        abort( "Attempt to deallocate storage %p not allocated or with corrupt header.\n"
    628630                                   "Possible cause is invalid pointer.",
    629631                                   addr );
    630                         #endif // __CFA_DEBUG__
    631632                } // if
    632633        } else {
    633634                #ifdef __CFA_DEBUG__
    634635                // Set free memory to garbage so subsequent usages might fail.
    635                 //memset( ((HeapManager.Storage *)header)->data, '\377', freeElem->blockSize - sizeof( HeapManager.Storage ) );
    636                 Memset( ((HeapManager.Storage *)header)->data, freeElem->blockSize - sizeof( HeapManager.Storage ) );
     636                memset( ((HeapManager.Storage *)header)->data, '\xde', freeElem->blockSize - sizeof( HeapManager.Storage ) );
     637                //Memset( ((HeapManager.Storage *)header)->data, freeElem->blockSize - sizeof( HeapManager.Storage ) );
    637638                #endif // __CFA_DEBUG__
    638639
     
    703704
    704705static void ?{}( HeapManager & manager ) with( manager ) {
    705         pageSize = sysconf( _SC_PAGESIZE );
     706        __page_size = sysconf( _SC_PAGESIZE );
     707        __map_prot = PROT_READ | PROT_WRITE | PROT_EXEC;
    706708
    707709        for ( unsigned int i = 0; i < NoBucketSizes; i += 1 ) { // initialize the free lists
     
    723725
    724726        char * end = (char *)sbrk( 0 );
    725         heapBegin = heapEnd = sbrk( (char *)ceiling2( (long unsigned int)end, pageSize ) - end ); // move start of heap to multiple of alignment
     727        heapBegin = heapEnd = sbrk( (char *)ceiling2( (long unsigned int)end, __page_size ) - end ); // move start of heap to multiple of alignment
    726728} // HeapManager
    727729
     
    741743        #ifdef __CFA_DEBUG__
    742744        if ( heapBoot ) {                                                                       // check for recursion during system boot
    743                 // DO NOT USE STREAMS AS THEY MAY BE UNAVAILABLE AT THIS POINT.
    744745                abort( "boot() : internal error, recursively invoked during system boot." );
    745746        } // if
     
    10281029        } // cmemalign
    10291030
     1031
    10301032        // Same as memalign(), but ISO/IEC 2011 C11 Section 7.22.2 states: the value of size shall be an integral multiple
    10311033    // of alignment. This requirement is universally ignored.
     
    10451047        } // posix_memalign
    10461048
     1049
    10471050        // Allocates size bytes and returns a pointer to the allocated memory. The memory address shall be a multiple of the
    10481051        // page size.  It is equivalent to memalign(sysconf(_SC_PAGESIZE),size).
    10491052        void * valloc( size_t size ) {
    1050                 return memalign( pageSize, size );
     1053                return memalign( __page_size, size );
    10511054        } // valloc
    10521055
     
    10541057        // Same as valloc but rounds size to multiple of page size.
    10551058        void * pvalloc( size_t size ) {
    1056                 return memalign( pageSize, ceiling2( size, pageSize ) );
     1059                return memalign( __page_size, ceiling2( size, __page_size ) );
    10571060        } // pvalloc
    10581061
     
    11931196                choose( option ) {
    11941197                  case M_TOP_PAD:
    1195                         heapExpand = ceiling2( value, pageSize ); return 1;
     1198                        heapExpand = ceiling2( value, __page_size ); return 1;
    11961199                  case M_MMAP_THRESHOLD:
    11971200                        if ( setMmapStart( value ) ) return 1;
  • src/AST/Convert.cpp

    r72a3aff r7a70fb2  
    205205                ftype->parameters = get<DeclarationWithType>().acceptL(node->params);
    206206
    207                 ftype->forall = get<TypeDecl>().acceptL( node->type->forall );
     207                ftype->forall = get<TypeDecl>().acceptL( node->type_params );
     208                if (!node->assertions.empty()) {
     209                        assert(!ftype->forall.empty());
     210                        // find somewhere to place assertions back, for convenience it is the last slot
     211                        ftype->forall.back()->assertions = get<DeclarationWithType>().acceptL(node->assertions);
     212                }
    208213
    209214                visitType(node->type, ftype);
     
    602607
    603608                for (decltype(src->begin()) src_i = src->begin(); src_i != src->end(); src_i++) {
    604                         rslt->add( src_i->first,
     609                        rslt->add( src_i->first.typeString(),
    605610                                   get<Type>().accept1(src_i->second) );
    606                 }
    607 
    608                 for (decltype(src->beginVar()) src_i = src->beginVar(); src_i != src->endVar(); src_i++) {
    609                         rslt->addVar( src_i->first,
    610                                       get<Expression>().accept1(src_i->second) );
    611611                }
    612612
     
    12121212                // ty->returnVals = get<DeclarationWithType>().acceptL( node->returns );
    12131213                // ty->parameters = get<DeclarationWithType>().acceptL( node->params );
    1214                 ty->forall = get<TypeDecl>().acceptL( node->forall );
     1214
     1215                auto types = get<TypeInstType>().acceptL( node->forall );
     1216                for (auto t : types) {
     1217                        auto newT = new TypeDecl(*t->baseType);
     1218                        newT->name = t->name; // converted by typeString()
     1219                        for (auto asst : newT->assertions) delete asst;
     1220                        newT->assertions.clear();
     1221                        ty->forall.push_back(newT);
     1222                }
     1223                auto assts = get<VariableExpr>().acceptL( node->assertions );
     1224                if (!assts.empty()) {
     1225                        assert(!types.empty());
     1226                        for (auto asst : assts) {
     1227                                auto newDecl = new ObjectDecl(*strict_dynamic_cast<ObjectDecl*>(asst->var));
     1228                                delete newDecl->type;
     1229                                newDecl->type = asst->result->clone();
     1230                                newDecl->storageClasses.is_extern = true; // hack
     1231                                ty->forall.back()->assertions.push_back(newDecl);
     1232                        }
     1233                }
     1234
    12151235                return visitType( node, ty );
    12161236        }
     
    12991319                        ty = new TypeInstType{
    13001320                                cv( node ),
    1301                                 node->name,
     1321                                node->typeString(),
    13021322                                get<TypeDecl>().accept1( node->base ),
    13031323                                get<Attribute>().acceptL( node->attributes )
     
    13061326                        ty = new TypeInstType{
    13071327                                cv( node ),
    1308                                 node->name,
     1328                                node->typeString(),
    13091329                                node->kind == ast::TypeDecl::Ftype,
    13101330                                get<Attribute>().acceptL( node->attributes )
     
    14311451        /// at conversion stage, all created nodes are guaranteed to be unique, therefore
    14321452        /// const_casting out of smart pointers is permitted.
    1433         std::unordered_map< const BaseSyntaxNode *, ast::ptr<ast::Node> > cache = {};
     1453        std::unordered_map< const BaseSyntaxNode *, ast::readonly<ast::Node> > cache = {};
    14341454
    14351455        // Local Utilities:
     
    15651585                // can function type have attributes? seems not to be the case.
    15661586                // visitType(old->type, ftype);
     1587
     1588                // collect assertions and put directly in FunctionDecl
     1589                std::vector<ast::ptr<ast::DeclWithType>> assertions;
     1590                for (auto & param: forall) {
     1591                        for (auto & asst: param->assertions) {
     1592                                assertf(asst->unique(), "newly converted decl must be unique");
     1593                                assertions.emplace_back(asst);
     1594                        }
     1595                        auto mut = param.get_and_mutate();
     1596                        assertf(mut == param, "newly converted decl must be unique");
     1597                        mut->assertions.clear();
     1598                }
    15671599
    15681600                auto decl = new ast::FunctionDecl{
     
    15841616                cache.emplace( old, decl );
    15851617
     1618                decl->assertions = std::move(assertions);
    15861619                decl->withExprs = GET_ACCEPT_V(withExprs, Expr);
    15871620                decl->stmts = GET_ACCEPT_1(statements, CompoundStmt);
     
    20662099        }
    20672100
     2101        // TypeSubstitution shouldn't exist yet in old.
    20682102        ast::TypeSubstitution * convertTypeSubstitution(const TypeSubstitution * old) {
    2069 
     2103               
    20702104                if (!old) return nullptr;
    2071 
     2105                if (old->empty()) return nullptr;
     2106                assert(false);
     2107
     2108                /*
    20722109                ast::TypeSubstitution *rslt = new ast::TypeSubstitution();
    20732110
     
    20772114                }
    20782115
    2079                 for (decltype(old->beginVar()) old_i = old->beginVar(); old_i != old->endVar(); old_i++) {
    2080                         rslt->addVar( old_i->first,
    2081                                       getAccept1<ast::Expr>(old_i->second) );
    2082                 }
    2083 
    20842116                return rslt;
     2117                */
    20852118        }
    20862119
     
    26102643                        ty->params.emplace_back(v->get_type());
    26112644                }
    2612                 ty->forall = GET_ACCEPT_V( forall, TypeDecl );
     2645                // xxx - when will this be non-null?
     2646                // will have to create dangling (no-owner) decls to be pointed to
     2647                auto foralls = GET_ACCEPT_V( forall, TypeDecl );
     2648
     2649                for (auto & param : foralls) {
     2650                        ty->forall.emplace_back(new ast::TypeInstType(param->name, param));
     2651                        for (auto asst : param->assertions) {
     2652                                ty->assertions.emplace_back(new ast::VariableExpr({}, asst));
     2653                        }
     2654                }
    26132655                visitType( old, ty );
    26142656        }
  • src/AST/Decl.cpp

    r72a3aff r7a70fb2  
    5050
    5151FunctionDecl::FunctionDecl( const CodeLocation & loc, const std::string & name,
    52                 std::vector<ptr<TypeDecl>>&& forall,
    53                 std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,
    54                 CompoundStmt * stmts, Storage::Classes storage, Linkage::Spec linkage,
    55                 std::vector<ptr<Attribute>>&& attrs, Function::Specs fs, bool isVarArgs)
    56         : DeclWithType( loc, name, storage, linkage, std::move(attrs), fs ), params(std::move(params)), returns(std::move(returns)),
    57           stmts( stmts ) {
    58                   FunctionType * ftype = new FunctionType(static_cast<ArgumentFlag>(isVarArgs));
    59                   for (auto & param : this->params) {
    60                           ftype->params.emplace_back(param->get_type());
    61                   }
    62                   for (auto & ret : this->returns) {
    63                           ftype->returns.emplace_back(ret->get_type());
    64                   }
    65                   ftype->forall = std::move(forall);
    66                   this->type = ftype;
    67           }
     52        std::vector<ptr<TypeDecl>>&& forall,
     53        std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,
     54        CompoundStmt * stmts, Storage::Classes storage, Linkage::Spec linkage,
     55        std::vector<ptr<Attribute>>&& attrs, Function::Specs fs, bool isVarArgs)
     56: DeclWithType( loc, name, storage, linkage, std::move(attrs), fs ), params(std::move(params)), returns(std::move(returns)),
     57        type_params(std::move(forall)), stmts( stmts ) {
     58        FunctionType * ftype = new FunctionType(static_cast<ArgumentFlag>(isVarArgs));
     59        for (auto & param : this->params) {
     60                ftype->params.emplace_back(param->get_type());
     61        }
     62        for (auto & ret : this->returns) {
     63                ftype->returns.emplace_back(ret->get_type());
     64        }
     65        for (auto & tp : this->type_params) {
     66                ftype->forall.emplace_back(new TypeInstType(tp->name, tp));
     67        }
     68        this->type = ftype;
     69}
    6870
    6971
  • src/AST/Decl.hpp

    r72a3aff r7a70fb2  
    127127        std::vector<ptr<DeclWithType>> params;
    128128        std::vector<ptr<DeclWithType>> returns;
     129        std::vector<ptr<TypeDecl>> type_params;
     130        std::vector<ptr<DeclWithType>> assertions;
    129131        // declared type, derived from parameter declarations
    130132        ptr<FunctionType> type;
    131133        ptr<CompoundStmt> stmts;
    132134        std::vector< ptr<Expr> > withExprs;
     135
    133136
    134137        FunctionDecl( const CodeLocation & loc, const std::string & name, std::vector<ptr<TypeDecl>>&& forall,
  • src/AST/Expr.cpp

    r72a3aff r7a70fb2  
    206206        assert( aggregate->result );
    207207
    208         // Deep copy on result type avoids mutation on transitively multiply referenced object.
    209         //
    210         // Example, adapted from parts of builtins and bootloader:
    211         //
    212         // forall(dtype T)
    213         // struct __Destructor {
    214         //   T * object;
    215         //   void (*dtor)(T *);
    216         // };
    217         //
    218         // forall(dtype S)
    219         // void foo(__Destructor(S) &d) {
    220         //   if (d.dtor) {  // here
    221         //   }
    222         // }
    223         //
    224         // Let e be the "d.dtor" guard espression, which is MemberExpr after resolve.  Let d be the
    225         // declaration of member __Destructor.dtor (an ObjectDecl), as accessed via the top-level
    226         // declaration of __Destructor.  Consider the types e.result and d.type.  In the old AST, one
    227         // is a clone of the other.  Ordinary new-AST use would set them up as a multiply-referenced
    228         // object.
    229         //
    230         // e.result: PointerType
    231         // .base: FunctionType
    232         // .params.front(): ObjectDecl, the anonymous parameter of type T*
    233         // .type: PointerType
    234         // .base: TypeInstType
    235         // let x = that
    236         // let y = similar, except start from d.type
    237         //
    238         // Consider two code lines down, genericSubstitution(...).apply(result).
    239         //
    240         // Applying this chosen-candidate's type substitution means modifying x, substituting
    241         // S for T.  This mutation should affect x and not y.
    242 
    243         result = deepCopy(mem->get_type());
     208        result = mem->get_type();
    244209
    245210        // substitute aggregate generic parameters into member type
  • src/AST/Pass.hpp

    r72a3aff r7a70fb2  
    3434
    3535#include "AST/SymbolTable.hpp"
    36 
    37 #include "AST/ForallSubstitutionTable.hpp"
    3836
    3937// Private prelude header, needed for some of the magic tricks this class pulls off
     
    6664// | WithVisitorRef        - provides an pointer to the templated visitor wrapper
    6765// | WithSymbolTable       - provides symbol table functionality
    68 // | WithForallSubstitutor - maintains links between TypeInstType and TypeDecl under mutation
    6966//
    7067// Other Special Members:
     
    258255        container_t< ptr<node_t> > call_accept( const container_t< ptr<node_t> > & container );
    259256
    260         /// Mutate forall-list, accounting for presence of type substitution map
    261         template<typename node_t>
    262         void mutate_forall( const node_t *& );
    263 
    264257public:
    265258        /// Logic to call the accept and mutate the parent if needed, delegates call to accept
     
    398391};
    399392
    400 /// Use when the templated visitor needs to keep TypeInstType instances properly linked to TypeDecl
    401 struct WithForallSubstitutor {
    402         ForallSubstitutionTable subs;
    403 };
    404 
    405393}
    406394
  • src/AST/Pass.impl.hpp

    r72a3aff r7a70fb2  
    367367        }
    368368
    369 
    370         template< typename core_t >
    371         template< typename node_t >
    372         void ast::Pass< core_t >::mutate_forall( const node_t *& node ) {
    373                 if ( auto subs = __pass::forall::subs( core, 0 ) ) {
    374                         // tracking TypeDecl substitution, full clone
    375                         if ( node->forall.empty() ) return;
    376 
    377                         node_t * mut = __pass::mutate<core_t>( node );
    378                         mut->forall = subs->clone( node->forall, *this );
    379                         node = mut;
    380                 } else {
    381                         // not tracking TypeDecl substitution, just mutate
    382                         maybe_accept( node, &node_t::forall );
    383                 }
    384         }
    385369}
    386370
     
    504488                        __pass::symtab::addId( core, 0, func );
    505489                        VISIT(
    506                                 // parameter declarations are now directly here
     490                                // parameter declarations
    507491                                maybe_accept( node, &FunctionDecl::params );
    508492                                maybe_accept( node, &FunctionDecl::returns );
    509                                 // foralls are still in function type
    510                                 maybe_accept( node, &FunctionDecl::type );
     493                                // type params and assertions
     494                                maybe_accept( node, &FunctionDecl::type_params );
     495                                maybe_accept( node, &FunctionDecl::assertions );
    511496                                // First remember that we are now within a function.
    512497                                ValueGuard< bool > oldInFunction( inFunction );
     
    17581743
    17591744        VISIT({
    1760                 guard_forall_subs forall_guard { *this, node };
    1761                 mutate_forall( node );
     1745                // guard_forall_subs forall_guard { *this, node };
     1746                // mutate_forall( node );
     1747                maybe_accept( node, &FunctionType::assertions );
    17621748                maybe_accept( node, &FunctionType::returns );
    17631749                maybe_accept( node, &FunctionType::params  );
     
    19811967                {
    19821968                        bool mutated = false;
    1983                         std::unordered_map< std::string, ast::ptr< ast::Type > > new_map;
     1969                        std::unordered_map< ast::TypeInstType::TypeEnvKey, ast::ptr< ast::Type > > new_map;
    19841970                        for ( const auto & p : node->typeEnv ) {
    19851971                                guard_symtab guard { *this };
     
    19941980                        }
    19951981                }
    1996 
    1997                 {
    1998                         bool mutated = false;
    1999                         std::unordered_map< std::string, ast::ptr< ast::Expr > > new_map;
    2000                         for ( const auto & p : node->varEnv ) {
    2001                                 guard_symtab guard { *this };
    2002                                 auto new_node = p.second->accept( *this );
    2003                                 if (new_node != p.second) mutated = true;
    2004                                 new_map.insert({ p.first, new_node });
    2005                         }
    2006                         if (mutated) {
    2007                                 auto new_node = __pass::mutate<core_t>( node );
    2008                                 new_node->varEnv.swap( new_map );
    2009                                 node = new_node;
    2010                         }
    2011                 }
    20121982        )
    20131983
  • src/AST/Pass.proto.hpp

    r72a3aff r7a70fb2  
    413413                static inline auto leave( core_t &, long, const ast::FunctionType * ) {}
    414414
    415                 // Get the substitution table, if present
    416                 template<typename core_t>
    417                 static inline auto subs( core_t & core, int ) -> decltype( &core.subs ) {
    418                         return &core.subs;
    419                 }
    420 
    421                 template<typename core_t>
    422                 static inline ast::ForallSubstitutionTable * subs( core_t &, long ) { return nullptr; }
    423 
    424415                // Replaces a TypeInstType's base TypeDecl according to the table
    425416                template<typename core_t>
  • src/AST/Print.cpp

    r72a3aff r7a70fb2  
    155155        }
    156156
     157        void print( const ast::FunctionType::AssertionList & assts ) {
     158                if (assts.empty()) return;
     159                os << "with assertions" << endl;
     160                ++indent;
     161                printAll(assts);
     162                os << indent;
     163                --indent;
     164        }
     165
    157166        void print( const std::vector<ptr<Attribute>> & attrs ) {
    158167                if ( attrs.empty() ) return;
     
    206215        void preprint( const ast::NamedTypeDecl * node ) {
    207216                if ( ! node->name.empty() ) {
    208                         if( deterministic_output && isUnboundType(node->name) ) os << "[unbound]:";
    209                         else os << node->name << ": ";
     217                        os << node->name << ": ";
    210218                }
    211219
     
    261269        void preprint( const ast::FunctionType * node ) {
    262270                print( node->forall );
     271                print( node->assertions );
    263272                print( node->qualifiers );
    264273        }
     
    13751384        virtual const ast::Type * visit( const ast::TypeInstType * node ) override final {
    13761385                preprint( node );
    1377                 const auto & _name = deterministic_output && isUnboundType(node) ? "[unbound]" : node->name;
     1386                const auto & _name = deterministic_output && isUnboundType(node) ? "[unbound]" : node->typeString();
    13781387                os << "instance of type " << _name
    13791388                   << " (" << (node->kind == ast::TypeDecl::Ftype ? "" : "not ") << "function type)";
     
    15021511                os << indent << "Types:" << endl;
    15031512                for ( const auto& i : *node ) {
    1504                         os << indent+1 << i.first << " -> ";
     1513                        os << indent+1 << i.first.typeString() << " -> ";
    15051514                        indent += 2;
    15061515                        safe_print( i.second );
    1507                         indent -= 2;
    1508                         os << endl;
    1509                 }
    1510                 os << indent << "Non-types:" << endl;
    1511                 for ( auto i = node->beginVar(); i != node->endVar(); ++i ) {
    1512                         os << indent+1 << i->first << " -> ";
    1513                         indent += 2;
    1514                         safe_print( i->second );
    15151516                        indent -= 2;
    15161517                        os << endl;
  • src/AST/SymbolTable.cpp

    r72a3aff r7a70fb2  
    414414
    415415void SymbolTable::addFunction( const FunctionDecl * func ) {
    416         addTypes( func->type->forall );
     416        for (auto & td : func->type_params) {
     417                addType(td);
     418        }
     419        for (auto & asst : func->assertions) {
     420                addId(asst);
     421        }
     422        // addTypes( func->type->forall );
    417423        addIds( func->returns );
    418424        addIds( func->params );
  • src/AST/Type.cpp

    r72a3aff r7a70fb2  
    2121
    2222#include "Decl.hpp"
    23 #include "ForallSubstitutor.hpp" // for substituteForall
    2423#include "Init.hpp"
    2524#include "Common/utility.h"      // for copy, move
     
    9291// GENERATED END
    9392
    94 // --- ParameterizedType
    95 
    96 void FunctionType::initWithSub(
    97         const FunctionType & o, Pass< ForallSubstitutor > & sub
    98 ) {
    99         forall = sub.core( o.forall );
    100 }
    101 
    10293// --- FunctionType
    103 
    104 
    105 FunctionType::FunctionType( const FunctionType & o )
    106 : Type( o.qualifiers, copy( o.attributes ) ), returns(), params(),
    107   isVarArgs( o.isVarArgs ) {
    108         Pass< ForallSubstitutor > sub;
    109         initWithSub( o, sub );           // initialize substitution map
    110         returns = sub.core( o.returns ); // apply to return and parameter types
    111         params = sub.core( o.params );
    112 }
    113 
    11494namespace {
    11595        bool containsTtype( const std::vector<ptr<Type>> & l ) {
     
    199179                // TODO: once TypeInstType representation is updated, it should properly check
    200180                // if the context id is filled. this is a temporary hack for now
    201                 return isUnboundType(typeInst->name);
    202         }
    203         return false;
    204 }
    205 
    206 bool isUnboundType(const std::string & tname) {
    207         // xxx - look for a type name produced by renameTyVars.
    208 
    209         // TODO: once TypeInstType representation is updated, it should properly check
    210         // if the context id is filled. this is a temporary hack for now
    211         if (std::count(tname.begin(), tname.end(), '_') >= 3) {
    212                 return true;
     181                return typeInst->formal_usage > 0;
    213182        }
    214183        return false;
  • src/AST/Type.hpp

    r72a3aff r7a70fb2  
    3636
    3737template< typename T > class Pass;
    38 
    39 struct ForallSubstitutor;
    4038
    4139class Type : public Node {
     
    272270/// Type of a function `[R1, R2](*)(P1, P2, P3)`
    273271class FunctionType final : public Type {
    274         protected:
    275         /// initializes forall with substitutor
    276         void initWithSub( const FunctionType & o, Pass< ForallSubstitutor > & sub );
    277 public:
    278         using ForallList = std::vector<ptr<TypeDecl>>;
     272public:
     273        using ForallList = std::vector<ptr<TypeInstType>>;
     274        using AssertionList = std::vector<ptr<VariableExpr>>;
    279275        ForallList forall;
     276        AssertionList assertions;
    280277
    281278        std::vector<ptr<Type>> returns;
     
    292289        : Type(q), returns(), params(), isVarArgs(va) {}
    293290
    294         FunctionType( const FunctionType & o );
     291        FunctionType( const FunctionType & o ) = default;
    295292
    296293        /// true if either the parameters or return values contain a tttype
     
    397394public:
    398395        readonly<TypeDecl> base;
     396        // previously from renameTyVars; now directly use integer fields instead of synthesized strings
     397        // a nonzero value of formal_usage indicates a formal type (only used in function type)
     398        // a zero value of formal_usage indicates an actual type (referenced inside body of parametric structs and functions)
    399399        TypeDecl::Kind kind;
     400        int formal_usage;
     401        int expr_id;
     402
     403        // compact representation used for map lookups.
     404        struct TypeEnvKey {
     405                const TypeDecl * base;
     406                int formal_usage;
     407                int expr_id;
     408
     409                TypeEnvKey() = default;
     410                TypeEnvKey(const TypeDecl * base, int formal_usage = 0, int expr_id = 0): base(base), formal_usage(formal_usage), expr_id(expr_id) {}
     411                TypeEnvKey(const TypeInstType & inst): base(inst.base), formal_usage(inst.formal_usage), expr_id(inst.expr_id) {}
     412                std::string typeString() const { return std::string("_") + std::to_string(formal_usage) + "_" + std::to_string(expr_id) + "_" + base->name; }
     413                bool operator==(const TypeEnvKey & other) const { return base == other.base && formal_usage == other.formal_usage && expr_id == other.expr_id; }
     414
     415        };
     416
     417        bool operator==(const TypeInstType & other) const { return base == other.base && formal_usage == other.formal_usage && expr_id == other.expr_id; }
    400418
    401419        TypeInstType(
     
    409427        TypeInstType( const TypeInstType & o ) = default;
    410428
     429        TypeInstType( const TypeEnvKey & key )
     430        : BaseInstType(key.base->name), base(key.base), kind(key.base->kind), formal_usage(key.formal_usage), expr_id(key.expr_id) {}
     431
    411432        /// sets `base`, updating `kind` correctly
    412433        void set_base( const TypeDecl * );
     
    418439
    419440        const Type * accept( Visitor & v ) const override { return v.visit( this ); }
     441
     442        std::string typeString() const {
     443                if (formal_usage > 0) return std::string("_") + std::to_string(formal_usage) + "_" + std::to_string(expr_id) + "_" + name;
     444                else return name;
     445        }
    420446private:
    421447        TypeInstType * clone() const override { return new TypeInstType{ *this }; }
     
    510536
    511537bool isUnboundType(const Type * type);
    512 bool isUnboundType(const std::string & tname);
    513 
     538
     539}
     540
     541namespace std {
     542        template<>
     543        struct hash<typename ast::TypeInstType::TypeEnvKey> {
     544                size_t operator() (const ast::TypeInstType::TypeEnvKey & x) const {
     545                        const size_t p = 1000007;
     546                        size_t res = reinterpret_cast<size_t>(x.base);
     547                        res = p * res + x.formal_usage;
     548                        res = p * res + x.expr_id;
     549                        return res;
     550                }
     551        };
    514552}
    515553
  • src/AST/TypeEnvironment.cpp

    r72a3aff r7a70fb2  
    5252        for ( const auto & i : open ) {
    5353                if ( first ) { first = false; } else { out << ' '; }
    54                 out << i.first << "(" << i.second << ")";
     54                out << i.first.typeString() << "(" << i.second << ")";
    5555        }
    5656}
     
    6262                if(first) first = false;
    6363                else out << " ";
    64                 if( deterministic_output && isUnboundType(var) ) out << "[unbound]";
    65                 else out << var;
     64
     65                if( deterministic_output ) out << "[unbound]";
     66                else out << "_" << var.formal_usage << "_" << var.expr_id << "_";
     67
     68                out << var.base->name;
    6669        }
    6770        out << ")";
     
    7982}
    8083
    81 const EqvClass * TypeEnvironment::lookup( const std::string & var ) const {
     84const EqvClass * TypeEnvironment::lookup( const TypeInstType::TypeEnvKey & var ) const {
    8285        for ( ClassList::const_iterator i = env.begin(); i != env.end(); ++i ) {
    8386                if ( i->vars.find( var ) != i->vars.end() ) return &*i;
     
    106109
    107110void TypeEnvironment::add( const FunctionType::ForallList & tyDecls ) {
    108         for ( const TypeDecl * tyDecl : tyDecls ) {
     111        for ( auto & tyDecl : tyDecls ) {
    109112                env.emplace_back( tyDecl );
    110113        }
     
    119122void TypeEnvironment::writeToSubstitution( TypeSubstitution & sub ) const {
    120123        for ( const auto & clz : env ) {
    121                 std::string clzRep;
     124                TypeInstType::TypeEnvKey clzRep;
     125                bool first = true;
    122126                for ( const auto & var : clz.vars ) {
    123127                        if ( clz.bound ) {
    124128                                sub.add( var, clz.bound );
    125                         } else if ( clzRep.empty() ) {
     129                        } else if ( first ) {
    126130                                clzRep = var;
     131                                first = false;
    127132                        } else {
    128                                 sub.add( var, new TypeInstType{ clzRep, clz.data.kind } );
     133                                sub.add( var, new TypeInstType{ clzRep } );
    129134                        }
    130135                }
     
    141146        struct Occurs : public ast::WithVisitorRef<Occurs> {
    142147                bool result;
    143                 std::set< std::string > vars;
     148                std::unordered_set< TypeInstType::TypeEnvKey > vars;
    144149                const TypeEnvironment & tenv;
    145150
    146                 Occurs( const std::string & var, const TypeEnvironment & env )
     151                Occurs( const TypeInstType::TypeEnvKey & var, const TypeEnvironment & env )
    147152                : result( false ), vars(), tenv( env ) {
    148153                        if ( const EqvClass * clz = tenv.lookup( var ) ) {
     
    154159
    155160                void previsit( const TypeInstType * typeInst ) {
    156                         if ( vars.count( typeInst->name ) ) {
     161                        if ( vars.count( *typeInst ) ) {
    157162                                result = true;
    158                         } else if ( const EqvClass * clz = tenv.lookup( typeInst->name ) ) {
     163                        } else if ( const EqvClass * clz = tenv.lookup( *typeInst ) ) {
    159164                                if ( clz->bound ) {
    160165                                        clz->bound->accept( *visitor );
     
    165170
    166171        /// true if `var` occurs in `ty` under `env`
    167         bool occurs( const Type * ty, const std::string & var, const TypeEnvironment & env ) {
     172        bool occurs( const Type * ty, const TypeInstType::TypeEnvKey & var, const TypeEnvironment & env ) {
    168173                Pass<Occurs> occur{ var, env };
    169174                maybe_accept( ty, occur );
     
    280285        // remove references from bound type, so that type variables can only bind to value types
    281286        ptr<Type> target = bindTo->stripReferences();
    282         auto tyvar = open.find( typeInst->name );
     287        auto tyvar = open.find( *typeInst );
    283288        assert( tyvar != open.end() );
    284289        if ( ! tyVarCompatible( tyvar->second, target ) ) return false;
    285         if ( occurs( target, typeInst->name, *this ) ) return false;
    286 
    287         auto it = internal_lookup( typeInst->name );
     290        if ( occurs( target, *typeInst, *this ) ) return false;
     291
     292        auto it = internal_lookup( *typeInst );
    288293        if ( it != env.end() ) {
    289294                if ( it->bound ) {
     
    308313        } else {
    309314                env.emplace_back(
    310                         typeInst->name, target, widen.first && widen.second, data );
     315                        *typeInst, target, widen.first && widen.second, data );
    311316        }
    312317        return true;
     
    318323                WidenMode widen, const SymbolTable & symtab
    319324) {
    320         auto c1 = internal_lookup( var1->name );
    321         auto c2 = internal_lookup( var2->name );
     325        auto c1 = internal_lookup( *var1 );
     326        auto c2 = internal_lookup( *var2 );
    322327
    323328        // exit early if variables already bound together
     
    333338        if ( c1 != env.end() ) {
    334339                if ( c1->bound ) {
    335                         if ( occurs( c1->bound, var2->name, *this ) ) return false;
     340                        if ( occurs( c1->bound, *var2, *this ) ) return false;
    336341                        type1 = c1->bound;
    337342                }
     
    340345        if ( c2 != env.end() ) {
    341346                if ( c2->bound ) {
    342                         if ( occurs( c2->bound, var1->name, *this ) ) return false;
     347                        if ( occurs( c2->bound, *var1, *this ) ) return false;
    343348                        type2 = c2->bound;
    344349                }
     
    378383        } else if ( c1 != env.end() ) {
    379384                // var2 unbound, add to env[c1]
    380                 c1->vars.emplace( var2->name );
     385                c1->vars.emplace( *var2 );
    381386                c1->allowWidening = widen1;
    382387                c1->data.isComplete |= data.isComplete;
    383388        } else if ( c2 != env.end() ) {
    384389                // var1 unbound, add to env[c2]
    385                 c2->vars.emplace( var1->name );
     390                c2->vars.emplace( *var1 );
    386391                c2->allowWidening = widen2;
    387392                c2->data.isComplete |= data.isComplete;
    388393        } else {
    389394                // neither var bound, create new class
    390                 env.emplace_back( var1->name, var2->name, widen1 && widen2, data );
     395                env.emplace_back( *var1, *var2, widen1 && widen2, data );
    391396        }
    392397
     
    452457}
    453458
    454 TypeEnvironment::ClassList::iterator TypeEnvironment::internal_lookup( const std::string & var ) {
     459TypeEnvironment::ClassList::iterator TypeEnvironment::internal_lookup( const TypeInstType::TypeEnvKey & var ) {
    455460        for ( ClassList::iterator i = env.begin(); i != env.end(); ++i ) {
    456461                if ( i->vars.count( var ) ) return i;
  • src/AST/TypeEnvironment.hpp

    r72a3aff r7a70fb2  
    5555/// recorded. More investigation is needed.
    5656struct AssertCompare {
    57         bool operator()( const DeclWithType * d1, const DeclWithType * d2 ) const {
    58                 int cmp = d1->name.compare( d2->name );
    59                 return cmp < 0 || ( cmp == 0 && d1->get_type() < d2->get_type() );
     57        bool operator()( const VariableExpr * d1, const VariableExpr * d2 ) const {
     58                int cmp = d1->var->name.compare( d2->var->name );
     59                return cmp < 0 || ( cmp == 0 && d1->result < d2->result );
    6060        }
    6161};
     
    7070
    7171/// Set of assertions pending satisfaction
    72 using AssertionSet = std::map< readonly<DeclWithType>, AssertionSetValue, AssertCompare >;
     72using AssertionSet = std::map< const VariableExpr *, AssertionSetValue, AssertCompare >;
    7373
    7474/// Set of open variables
    75 using OpenVarSet = std::unordered_map< std::string, TypeDecl::Data >;
     75using OpenVarSet = std::unordered_map< TypeInstType::TypeEnvKey, TypeDecl::Data >;
    7676
    7777/// Merges one set of open vars into another
     
    8989/// they bind to.
    9090struct EqvClass {
    91         std::set< std::string > vars;
     91        std::unordered_set< TypeInstType::TypeEnvKey > vars;
    9292        ptr<Type> bound;
    9393        bool allowWidening;
     
    101101
    102102        /// Singleton class constructor from TypeDecl
    103         EqvClass( const TypeDecl * decl )
    104         : vars{ decl->name }, bound(), allowWidening( true ), data( decl ) {}
     103        EqvClass( const TypeInstType * inst )
     104        : vars{ *inst }, bound(), allowWidening( true ), data( inst->base ) {}
    105105
    106106        /// Singleton class constructor from substitution
    107         EqvClass( const std::string & v, const Type * b )
     107        EqvClass( const TypeInstType::TypeEnvKey & v, const Type * b )
    108108        : vars{ v }, bound( b ), allowWidening( false ), data( TypeDecl::Dtype, false ) {}
    109109
    110110        /// Single-var constructor (strips qualifiers from bound type)
    111         EqvClass( const std::string & v, const Type * b, bool w, const TypeDecl::Data & d )
     111        EqvClass( const TypeInstType::TypeEnvKey & v, const Type * b, bool w, const TypeDecl::Data & d )
    112112        : vars{ v }, bound( b ), allowWidening( w ), data( d ) {
    113113                reset_qualifiers( bound );
     
    115115
    116116        /// Double-var constructor
    117         EqvClass( const std::string & v, const std::string & u, bool w, const TypeDecl::Data & d )
     117        EqvClass( const TypeInstType::TypeEnvKey & v, const TypeInstType::TypeEnvKey & u, bool w, const TypeDecl::Data & d )
    118118        : vars{ v, u }, bound(), allowWidening( w ), data( d ) {}
    119119
     
    131131public:
    132132        /// Finds the equivalence class containing a variable; nullptr for none such
    133         const EqvClass * lookup( const std::string & var ) const;
     133        const EqvClass * lookup( const TypeInstType::TypeEnvKey & var ) const;
    134134
    135135        /// Add a new equivalence class for each type variable
     
    207207
    208208        /// Private lookup API; returns array index of string, or env.size() for not found
    209         ClassList::iterator internal_lookup( const std::string & );
     209        ClassList::iterator internal_lookup( const TypeInstType::TypeEnvKey & );
    210210};
    211211
  • src/AST/TypeSubstitution.cpp

    r72a3aff r7a70fb2  
    3939void TypeSubstitution::initialize( const TypeSubstitution &src, TypeSubstitution &dest ) {
    4040        dest.typeEnv.clear();
    41         dest.varEnv.clear();
    4241        dest.add( src );
    4342}
     
    4746                typeEnv[ i->first ] = i->second;
    4847        } // for
    49         for ( VarEnvType::const_iterator i = other.varEnv.begin(); i != other.varEnv.end(); ++i ) {
    50                 varEnv[ i->first ] = i->second;
    51         } // for
    5248}
    5349
    54 void TypeSubstitution::add( std::string formalType, const Type *actualType ) {
    55         typeEnv[ formalType ] = actualType;
     50void TypeSubstitution::add( const TypeInstType * formalType, const Type *actualType ) {
     51        typeEnv[ *formalType ] = actualType;
    5652}
    5753
    58 void TypeSubstitution::addVar( std::string formalExpr, const Expr *actualExpr ) {
    59         varEnv[ formalExpr ] = actualExpr;
     54void TypeSubstitution::add( const TypeInstType::TypeEnvKey & key, const Type * actualType) {
     55        typeEnv[ key ] = actualType;
    6056}
    6157
    62 void TypeSubstitution::remove( std::string formalType ) {
    63         TypeEnvType::iterator i = typeEnv.find( formalType );
     58void TypeSubstitution::remove( const TypeInstType * formalType ) {
     59        TypeEnvType::iterator i = typeEnv.find( *formalType );
    6460        if ( i != typeEnv.end() ) {
    65                 typeEnv.erase( formalType );
     61                typeEnv.erase( *formalType );
    6662        } // if
    6763}
    6864
    69 const Type *TypeSubstitution::lookup( std::string formalType ) const {
    70         TypeEnvType::const_iterator i = typeEnv.find( formalType );
     65const Type *TypeSubstitution::lookup( const TypeInstType * formalType ) const {
     66        TypeEnvType::const_iterator i = typeEnv.find( *formalType );
    7167
    7268        // break on not in substitution set
     
    7571        // attempt to transitively follow TypeInstType links.
    7672        while ( const TypeInstType *actualType = i->second.as<TypeInstType>()) {
    77                 const std::string& typeName = actualType->name;
    78 
    7973                // break cycles in the transitive follow
    80                 if ( formalType == typeName ) break;
     74                if ( *formalType == *actualType ) break;
    8175
    8276                // Look for the type this maps to, returning previous mapping if none-such
    83                 i = typeEnv.find( typeName );
     77                i = typeEnv.find( *actualType );
    8478                if ( i == typeEnv.end() ) return actualType;
    8579        }
     
    9084
    9185bool TypeSubstitution::empty() const {
    92         return typeEnv.empty() && varEnv.empty();
     86        return typeEnv.empty();
    9387}
    9488
     
    9892                TypeSubstitution * newEnv;
    9993                EnvTrimmer( const TypeSubstitution * env, TypeSubstitution * newEnv ) : env( env ), newEnv( newEnv ){}
    100                 void previsit( TypeDecl * tyDecl ) {
     94                void previsit( FunctionType * ftype ) {
    10195                        // transfer known bindings for seen type variables
    102                         if ( const Type * t = env->lookup( tyDecl->name ) ) {
    103                                 newEnv->add( tyDecl->name, t );
     96                        for (auto & formal : ftype->forall) {
     97                                if ( const Type * t = env->lookup( formal ) ) {
     98                                        newEnv->add( formal, t );
     99                                }
    104100                        }
    105101                }
     
    130126
    131127const Type * TypeSubstitution::Substituter::postvisit( const TypeInstType *inst ) {
    132         BoundVarsType::const_iterator bound = boundVars.find( inst->name );
     128        BoundVarsType::const_iterator bound = boundVars.find( *inst );
    133129        if ( bound != boundVars.end() ) return inst;
    134130
    135         TypeEnvType::const_iterator i = sub.typeEnv.find( inst->name );
     131        TypeEnvType::const_iterator i = sub.typeEnv.find( *inst );
    136132        if ( i == sub.typeEnv.end() ) {
    137133                return inst;
     
    141137                // TODO: investigate preventing type variables from being bound to themselves in the first place.
    142138                if ( const TypeInstType * replacement = i->second.as<TypeInstType>() ) {
    143                         if ( inst->name == replacement->name ) {
     139                        if ( *inst == *replacement ) {
    144140                                return inst;
    145141                        }
     
    156152}
    157153
    158 const Expr * TypeSubstitution::Substituter::postvisit( const NameExpr * nameExpr ) {
    159         VarEnvType::const_iterator i = sub.varEnv.find( nameExpr->name );
    160         if ( i == sub.varEnv.end() ) {
    161                 return nameExpr;
    162         } else {
    163                 subCount++;
    164                 return i->second;
    165         } // if
    166 }
    167 
    168154void TypeSubstitution::Substituter::previsit( const FunctionType * ptype ) {
    169155        GuardValue( boundVars );
    170156        // bind type variables from forall-qualifiers
    171157        if ( freeOnly ) {
    172                 for ( const TypeDecl * tyvar : ptype->forall ) {
    173                                 boundVars.insert( tyvar->name );
     158                for ( auto & tyvar : ptype->forall ) {
     159                                boundVars.insert( *tyvar );
    174160                } // for
    175161        } // if
    176162}
    177163
     164/*
    178165void TypeSubstitution::Substituter::handleAggregateType( const BaseInstType * type ) {
    179166        GuardValue( boundVars );
     
    184171                        if ( ! type->params.empty() ) {
    185172                                for ( const TypeDecl * tyvar : decl->params ) {
    186                                         boundVars.insert( tyvar->name );
     173                                        boundVars.insert( *tyvar );
    187174                                } // for
    188175                        } // if
     
    198185        handleAggregateType( aggregateUseType );
    199186}
     187*/
    200188
    201189} // namespace ast
  • src/AST/TypeSubstitution.hpp

    r72a3aff r7a70fb2  
    6969        }
    7070
    71         void add( std::string formalType, const Type *actualType );
     71        void add( const TypeInstType * formalType, const Type *actualType );
     72        void add( const TypeInstType::TypeEnvKey & key, const Type *actualType );
    7273        void add( const TypeSubstitution &other );
    73         void remove( std::string formalType );
    74         const Type *lookup( std::string formalType ) const;
     74        void remove( const TypeInstType * formalType );
     75        const Type *lookup( const TypeInstType * formalType ) const;
    7576        bool empty() const;
    76 
    77         void addVar( std::string formalExpr, const Expr *actualExpr );
    7877
    7978        template< typename FormalIterator, typename ActualIterator >
     
    101100        friend class Pass;
    102101
    103         typedef std::unordered_map< std::string, ptr<Type> > TypeEnvType;
    104         typedef std::unordered_map< std::string, ptr<Expr> > VarEnvType;
     102        typedef std::unordered_map< TypeInstType::TypeEnvKey, ptr<Type> > TypeEnvType;
    105103        TypeEnvType typeEnv;
    106         VarEnvType varEnv;
    107104
    108105  public:
     
    113110        auto   end() const -> decltype( typeEnv.  end() ) { return typeEnv.  end(); }
    114111
    115         auto beginVar()       -> decltype( varEnv.begin() ) { return varEnv.begin(); }
    116         auto   endVar()       -> decltype( varEnv.  end() ) { return varEnv.  end(); }
    117         auto beginVar() const -> decltype( varEnv.begin() ) { return varEnv.begin(); }
    118         auto   endVar() const -> decltype( varEnv.  end() ) { return varEnv.  end(); }
    119112};
    120113
     114// this is the only place where type parameters outside a function formal may be substituted.
    121115template< typename FormalIterator, typename ActualIterator >
    122116void TypeSubstitution::add( FormalIterator formalBegin, FormalIterator formalEnd, ActualIterator actualBegin ) {
     
    129123                        if ( const TypeExpr *actual = actualIt->template as<TypeExpr>() ) {
    130124                                if ( formal->name != "" ) {
    131                                         typeEnv[ formal->name ] = actual->type;
     125                                        typeEnv[ formal ] = actual->type;
    132126                                } // if
    133127                        } else {
     
    135129                        } // if
    136130                } else {
    137                         // TODO: type check the formal and actual parameters
    138                         if ( (*formalIt)->name != "" ) {
    139                                 varEnv[ (*formalIt)->name ] = *actualIt;
    140                         } // if
     131                       
    141132                } // if
    142133        } // for
    143134}
     135
     136
    144137
    145138template< typename FormalIterator, typename ActualIterator >
     
    147140        add( formalBegin, formalEnd, actualBegin );
    148141}
     142
    149143
    150144} // namespace ast
     
    164158
    165159                const Type * postvisit( const TypeInstType * aggregateUseType );
    166                 const Expr * postvisit( const NameExpr * nameExpr );
    167160
    168161                /// Records type variable bindings from forall-statements
    169162                void previsit( const FunctionType * type );
    170163                /// Records type variable bindings from forall-statements and instantiations of generic types
    171                 void handleAggregateType( const BaseInstType * type );
     164                // void handleAggregateType( const BaseInstType * type );
    172165
    173                 void previsit( const StructInstType * aggregateUseType );
    174                 void previsit( const UnionInstType * aggregateUseType );
     166                // void previsit( const StructInstType * aggregateUseType );
     167                // void previsit( const UnionInstType * aggregateUseType );
    175168
    176169                const TypeSubstitution & sub;
    177170                int subCount = 0;
    178171                bool freeOnly;
    179                 typedef std::unordered_set< std::string > BoundVarsType;
     172                typedef std::unordered_set< TypeInstType::TypeEnvKey > BoundVarsType;
    180173                BoundVarsType boundVars;
    181174
  • src/AST/module.mk

    r72a3aff r7a70fb2  
    3333        AST/Expr.cpp \
    3434        AST/Expr.hpp \
    35         AST/ForallSubstitutionTable.cpp \
    36         AST/ForallSubstitutionTable.hpp \
    37         AST/ForallSubstitutor.hpp \
    3835        AST/FunctionSpec.hpp \
    3936        AST/Fwd.hpp \
  • src/GenPoly/GenPoly.cc

    r72a3aff r7a70fb2  
    115115                if (!env) return type;
    116116                if (auto typeInst = dynamic_cast<const ast::TypeInstType*> (type)) {
    117                         auto newType = env->lookup(typeInst->name);
     117                        auto newType = env->lookup(typeInst);
    118118                        if (newType) return newType;
    119119                }
     
    172172
    173173                if ( auto typeInst = dynamic_cast< const ast::TypeInstType * >( type ) ) {
    174                         return tyVars.find(typeInst->name) != tyVars.end() ? type : nullptr;
     174                        return tyVars.find(typeInst->typeString()) != tyVars.end() ? type : nullptr;
    175175                } else if ( auto arrayType = dynamic_cast< const ast::ArrayType * >( type ) ) {
    176176                        return isPolyType( arrayType->base, env );
     
    552552        }
    553553
    554         void addToTyVarMap( const ast::TypeDecl * tyVar, TyVarMap & tyVarMap) {
    555                 tyVarMap.insert(tyVar->name, convData(ast::TypeDecl::Data{tyVar}));
     554        void addToTyVarMap( const ast::TypeInstType * tyVar, TyVarMap & tyVarMap) {
     555                tyVarMap.insert(tyVar->typeString(), convData(ast::TypeDecl::Data{tyVar->base}));
    556556        }
    557557
  • src/ResolvExpr/AdjustExprType.cc

    r72a3aff r7a70fb2  
    133133                const ast::Type * postvisit( const ast::TypeInstType * inst ) {
    134134                        // replace known function-type-variables with pointer-to-function
    135                         if ( const ast::EqvClass * eqvClass = tenv.lookup( inst->name ) ) {
     135                        if ( const ast::EqvClass * eqvClass = tenv.lookup( *inst ) ) {
    136136                                if ( eqvClass->data.kind == ast::TypeDecl::Ftype ) {
    137137                                        return new ast::PointerType{ inst };
  • src/ResolvExpr/CandidateFinder.cpp

    r72a3aff r7a70fb2  
    212212                // mark type variable and specialization cost of forall clause
    213213                convCost.incVar( function->forall.size() );
    214                 for ( const ast::TypeDecl * td : function->forall ) {
    215                         convCost.decSpec( td->assertions.size() );
    216                 }
     214                convCost.decSpec( function->assertions.size() );
    217215
    218216                return convCost;
     
    223221                ast::AssertionSet & need
    224222        ) {
    225                 for ( const ast::TypeDecl * tyvar : type->forall ) {
    226                         unifiableVars[ tyvar->name ] = ast::TypeDecl::Data{ tyvar };
    227                         for ( const ast::DeclWithType * assn : tyvar->assertions ) {
    228                                 need[ assn ].isUsed = true;
    229                         }
     223                for ( auto & tyvar : type->forall ) {
     224                        unifiableVars[ *tyvar ] = ast::TypeDecl::Data{ tyvar->base };
     225                }
     226                for ( auto & assn : type->assertions ) {
     227                        need[ assn ].isUsed = true;
    230228                }
    231229        }
     
    953951                                                auto inst = dynamic_cast< const ast::TypeInstType * >( funcResult )
    954952                                        ) {
    955                                                 if ( const ast::EqvClass * clz = func->env.lookup( inst->name ) ) {
     953                                                if ( const ast::EqvClass * clz = func->env.lookup( *inst ) ) {
    956954                                                        if ( auto function = clz->bound.as< ast::FunctionType >() ) {
    957955                                                                CandidateRef newFunc{ new Candidate{ *func } };
     
    10771075                        assert( toType );
    10781076                        toType = resolveTypeof( toType, symtab );
    1079                         toType = SymTab::validateType( castExpr->location, toType, symtab );
     1077                        // toType = SymTab::validateType( castExpr->location, toType, symtab );
    10801078                        toType = adjustExprType( toType, tenv, symtab );
    10811079
     
    11621160
    11631161                                        if(auto insttype = dynamic_cast<const ast::TypeInstType*>(expr)) {
    1164                                                 auto td = cand->env.lookup(insttype->name);
     1162                                                auto td = cand->env.lookup(*insttype);
    11651163                                                if(!td) { continue; }
    11661164                                                expr = td->bound.get();
     
    15681566                                // calculate target type
    15691567                                const ast::Type * toType = resolveTypeof( initAlt.type, symtab );
    1570                                 toType = SymTab::validateType( initExpr->location, toType, symtab );
     1568                                // toType = SymTab::validateType( initExpr->location, toType, symtab );
    15711569                                toType = adjustExprType( toType, tenv, symtab );
    15721570                                // The call to find must occur inside this loop, otherwise polymorphic return
  • src/ResolvExpr/CastCost.cc

    r72a3aff r7a70fb2  
    202202) {
    203203        if ( auto typeInst = dynamic_cast< const ast::TypeInstType * >( dst ) ) {
    204                 if ( const ast::EqvClass * eqvClass = env.lookup( typeInst->name ) ) {
     204                if ( const ast::EqvClass * eqvClass = env.lookup( *typeInst ) ) {
    205205                        // check cast cost against bound type, if present
    206206                        if ( eqvClass->bound ) {
  • src/ResolvExpr/CommonType.cc

    r72a3aff r7a70fb2  
    713713                        const ast::Type * base = oPtr->base;
    714714                        if ( auto var = dynamic_cast< const ast::TypeInstType * >( base ) ) {
    715                                 auto entry = open.find( var->name );
     715                                auto entry = open.find( *var );
    716716                                if ( entry != open.end() ) {
    717717                                        ast::AssertionSet need, have;
  • src/ResolvExpr/ConversionCost.cc

    r72a3aff r7a70fb2  
    498498) {
    499499        if ( const ast::TypeInstType * inst = dynamic_cast< const ast::TypeInstType * >( dst ) ) {
    500                 if ( const ast::EqvClass * eqv = env.lookup( inst->name ) ) {
     500                if ( const ast::EqvClass * eqv = env.lookup( *inst ) ) {
    501501                        if ( eqv->bound ) {
    502502                                return conversionCost(src, eqv->bound, srcIsLvalue, symtab, env );
     
    675675
    676676void ConversionCost_new::postvisit( const ast::TypeInstType * typeInstType ) {
    677         if ( const ast::EqvClass * eqv = env.lookup( typeInstType->name ) ) {
     677        if ( const ast::EqvClass * eqv = env.lookup( *typeInstType ) ) {
    678678                cost = costCalc( eqv->bound, dst, srcIsLvalue, symtab, env );
    679679        } else if ( const ast::TypeInstType * dstAsInst =
    680680                        dynamic_cast< const ast::TypeInstType * >( dst ) ) {
    681                 if ( typeInstType->name == dstAsInst->name ) {
     681                if ( *typeInstType == *dstAsInst ) {
    682682                        cost = Cost::zero;
    683683                }
  • src/ResolvExpr/FindOpenVars.cc

    r72a3aff r7a70fb2  
    112112                                // mark open/closed variables
    113113                                if ( nextIsOpen ) {
    114                                         for ( const ast::TypeDecl * decl : type->forall ) {
    115                                                 open[ decl->name ] = ast::TypeDecl::Data{ decl };
    116                                                 for ( const ast::DeclWithType * assert : decl->assertions ) {
    117                                                         need[ assert ].isUsed = false;
    118                                                 }
     114                                        for ( auto & decl : type->forall ) {
     115                                                open[ *decl ] = ast::TypeDecl::Data{ decl->base };
     116                                        }
     117                                        for ( auto & assert : type->assertions ) {
     118                                                need[ assert ].isUsed = false;
    119119                                        }
    120120                                } else {
    121                                         for ( const ast::TypeDecl * decl : type->forall ) {
    122                                                 closed[ decl->name ] = ast::TypeDecl::Data{ decl };
    123                                                 for ( const ast::DeclWithType * assert : decl->assertions ) {
    124                                                         have[ assert ].isUsed = false;
    125                                                 }
     121                                        for ( auto & decl : type->forall ) {
     122                                                closed[ *decl ] = ast::TypeDecl::Data{ decl->base };   
     123                                        }
     124                                        for ( auto & assert : type->assertions ) {
     125                                                have[ assert ].isUsed = false;
    126126                                        }
    127127                                }
  • src/ResolvExpr/PolyCost.cc

    r72a3aff r7a70fb2  
    6868
    6969        void previsit( const ast::TypeInstType * type ) {
    70                 if ( const ast::EqvClass * eqv = env_.lookup( type->name ) ) /* && */ if ( eqv->bound ) {
     70                if ( const ast::EqvClass * eqv = env_.lookup( *type ) ) /* && */ if ( eqv->bound ) {
    7171                        if ( const ast::TypeInstType * otherType = eqv->bound.as< ast::TypeInstType >() ) {
    7272                                if ( symtab.lookupType( otherType->name ) ) {
  • src/ResolvExpr/PtrsAssignable.cc

    r72a3aff r7a70fb2  
    134134        }
    135135        void postvisit( const ast::TypeInstType * inst ) {
    136                 if ( const ast::EqvClass * eqv = typeEnv.lookup( inst->name ) ) {
     136                if ( const ast::EqvClass * eqv = typeEnv.lookup( *inst ) ) {
    137137                        if ( eqv->bound ) {
    138138                                // T * = S * for any S depends on the type bound to T
     
    146146                const ast::TypeEnvironment & env ) {
    147147        if ( const ast::TypeInstType * dstAsInst = dynamic_cast< const ast::TypeInstType * >( dst ) ) {
    148                 if ( const ast::EqvClass * eqv = env.lookup( dstAsInst->name ) ) {
     148                if ( const ast::EqvClass * eqv = env.lookup( *dstAsInst ) ) {
    149149                        return ptrsAssignable( src, eqv->bound, env );
    150150                }
  • src/ResolvExpr/PtrsCastable.cc

    r72a3aff r7a70fb2  
    180180                                        }
    181181                                }
    182                         } else if ( const ast::EqvClass * eqvClass = env.lookup( inst->name ) ) {
     182                        } else if ( const ast::EqvClass * eqvClass = env.lookup( *inst ) ) {
    183183                                if ( eqvClass->data.kind == ast::TypeDecl::Ftype ) {
    184184                                        return -1;
     
    283283) {
    284284        if ( auto inst = dynamic_cast< const ast::TypeInstType * >( dst ) ) {
    285                 if ( const ast::EqvClass * eqvClass = env.lookup( inst->name ) ) {
     285                if ( const ast::EqvClass * eqvClass = env.lookup( *inst ) ) {
    286286                        return ptrsAssignable( src, eqvClass->bound, env );
    287287                }
  • src/ResolvExpr/RenameVars.cc

    r72a3aff r7a70fb2  
    1919#include <utility>                 // for pair
    2020
    21 #include "AST/ForallSubstitutionTable.hpp"
    2221#include "AST/Pass.hpp"
    2322#include "AST/Type.hpp"
     
    3938                int level = 0;
    4039                int resetCount = 0;
     40
     41                int next_expr_id = 1;
     42                int next_usage_id = 1;
    4143                ScopedMap< std::string, std::string > nameMap;
     44                ScopedMap< std::string, ast::TypeInstType::TypeEnvKey > idMap;
    4245        public:
    43                 ast::ForallSubstitutionTable subs;
    44 
    4546                void reset() {
    4647                        level = 0;
     
    5354                                type->name = it->second;
    5455                        }
     56                }
     57
     58                void nextUsage() {
     59                        ++next_usage_id;
    5560                }
    5661
     
    7883
    7984                const ast::TypeInstType * rename( const ast::TypeInstType * type ) {
    80                         // re-linking of base type handled by WithForallSubstitutor
    81 
    8285                        // rename
    83                         auto it = nameMap.find( type->name );
    84                         if ( it != nameMap.end() ) {
    85                                 // unconditionally mutate because map will *always* have different name,
    86                                 // if this mutates, will *always* have been mutated by ForallSubstitutor above
    87                                 ast::TypeInstType * mut = ast::mutate( type );
    88                                 mut->name = it->second;
     86                        auto it = idMap.find( type->name );
     87                        if ( it != idMap.end() ) {
     88                                // unconditionally mutate because map will *always* have different name
     89                                ast::TypeInstType * mut = ast::shallowCopy( type );
     90                                // reconcile base node since some copies might have been made
     91                                mut->base = it->second.base;
     92                                mut->formal_usage = it->second.formal_usage;
     93                                mut->expr_id = it->second.expr_id;
    8994                    type = mut;
    9095                        }
     
    9398                }
    9499
    95                 const ast::FunctionType * openLevel( const ast::FunctionType * type ) {
     100                const ast::FunctionType * openLevel( const ast::FunctionType * type, RenameMode mode ) {
    96101                        if ( type->forall.empty() ) return type;
    97 
    98                         nameMap.beginScope();
     102                        idMap.beginScope();
    99103
    100104                        // Load new names from this forall clause and perform renaming.
    101                         auto mutType = ast::mutate( type );
    102                         assert( type == mutType && "mutated type must be unique from ForallSubstitutor" );
    103                         for ( ast::ptr< ast::TypeDecl > & td : mutType->forall ) {
    104                                 assertf(dynamic_cast<ast::FunctionType *>(mutType), "renaming vars in non-function type");
    105                                 std::ostringstream output;
    106                                 output << "_" << resetCount << "_" << level << "_" << td->name;
    107                                 std::string newname =  output.str();
    108                                 nameMap[ td->name ] = newname;
    109                                 ++level;
    110 
    111                                 ast::TypeDecl * mutDecl = ast::mutate( td.get() );
    112                                 assert( td == mutDecl && "mutated decl must be unique from ForallSubstitutor" );
    113                                 mutDecl->name = newname;
    114                                 // assertion above means `td = mutDecl;` is unnecessary
    115                         }
    116                         // assertion above means `type = mutType;` is unnecessary
    117 
    118                         return type;
     105                        auto mutType = ast::shallowCopy( type );
     106                        // assert( type == mutType && "mutated type must be unique from ForallSubstitutor" );
     107                        for ( auto & td : mutType->forall ) {
     108                                auto mut = ast::shallowCopy( td.get() );
     109                                // assert( td == mutDecl && "mutated decl must be unique from ForallSubstitutor" );
     110
     111                                if (mode == GEN_EXPR_ID) {
     112                                        mut->expr_id = next_expr_id;
     113                                        mut->formal_usage = -1;
     114                                        ++next_expr_id;
     115                                }
     116                                else if (mode == GEN_USAGE) {
     117                                        assertf(mut->expr_id, "unfilled expression id in generating candidate type");
     118                                        mut->formal_usage = next_usage_id;
     119                                }
     120                                else {
     121                                        assert(false);
     122                                }
     123                                idMap[ td->name ] = ast::TypeInstType::TypeEnvKey(*mut);
     124                               
     125                                td = mut;
     126                        }
     127
     128                        return mutType;
    119129                }
    120130
    121131                void closeLevel( const ast::FunctionType * type ) {
    122132                        if ( type->forall.empty() ) return;
    123 
    124                         nameMap.endScope();
     133                        idMap.endScope();
    125134                }
    126135        };
     
    142151        };
    143152
    144         struct RenameVars_new /*: public ast::WithForallSubstitutor*/ {
    145                 #warning when old RenameVars goes away, replace hack below with global pass inheriting from WithForallSubstitutor
    146                 ast::ForallSubstitutionTable & subs = renaming.subs;
     153        struct RenameVars_new : public ast::PureVisitor /*: public ast::WithForallSubstitutor*/ {
     154                RenameMode mode;
    147155
    148156                const ast::FunctionType * previsit( const ast::FunctionType * type ) {
    149                         return renaming.openLevel( type );
     157                        return renaming.openLevel( type, mode );
    150158                }
    151159
     
    163171
    164172                const ast::TypeInstType * previsit( const ast::TypeInstType * type ) {
     173                        if (mode == GEN_USAGE && !type->formal_usage) return type; // do not rename an actual type
    165174                        return renaming.rename( type );
    166175                }
     
    177186}
    178187
    179 const ast::Type * renameTyVars( const ast::Type * t ) {
    180         ast::Type *tc = ast::deepCopy(t);
     188const ast::Type * renameTyVars( const ast::Type * t, RenameMode mode ) {
     189        // ast::Type *tc = ast::deepCopy(t);
    181190        ast::Pass<RenameVars_new> renamer;
    182 //      return t->accept( renamer );
    183         return tc->accept( renamer );
     191        renamer.core.mode = mode;
     192        if (mode == GEN_USAGE) {
     193                renaming.nextUsage();
     194        }
     195        return t->accept( renamer );
    184196}
    185197
  • src/ResolvExpr/RenameVars.h

    r72a3aff r7a70fb2  
    3030        /// Provides a consistent renaming of forall type names in a hierarchy by prefixing them with a unique "level" ID
    3131        void renameTyVars( Type * );
    32         const ast::Type * renameTyVars( const ast::Type * );
     32
     33        enum RenameMode {
     34                GEN_USAGE, // for type in VariableExpr
     35                GEN_EXPR_ID // for type in decl
     36        };
     37        const ast::Type * renameTyVars( const ast::Type *, RenameMode mode = GEN_USAGE );
    3338
    3439        /// resets internal state of renamer to avoid overflow
    3540        void resetTyVarRenaming();
     41
     42       
    3643} // namespace ResolvExpr
    3744
  • src/ResolvExpr/ResolveTypeof.cc

    r72a3aff r7a70fb2  
    1515
    1616#include "ResolveTypeof.h"
     17#include "RenameVars.h"
    1718
    1819#include <cassert>               // for assert
     
    218219                        mutDecl->mangleName = Mangle::mangle(mutDecl); // do not mangle unnamed variables
    219220               
     221                mutDecl->type = renameTyVars(mutDecl->type, RenameMode::GEN_EXPR_ID);
    220222                mutDecl->isTypeFixed = true;
    221223                return mutDecl;
  • src/ResolvExpr/Resolver.cc

    r72a3aff r7a70fb2  
    986986                };
    987987        } // anonymous namespace
    988 
    989988        /// Check if this expression is or includes a deleted expression
    990989        const ast::DeletedExpr * findDeletedExpr( const ast::Expr * expr ) {
     
    13751374                        }
    13761375
    1377                         // handle assertions. (seems deep)
     1376                        // handle assertions
    13781377
    13791378                        symtab.enterScope();
    1380                         for (auto & typeParam : mutType->forall) {
    1381                                 auto mutParam = typeParam.get_and_mutate();
    1382                                 symtab.addType(mutParam);
    1383                                 for (auto & asst : mutParam->assertions) {
    1384                                         asst = fixObjectType(asst.strict_as<ast::ObjectDecl>(), symtab);
    1385                                         symtab.addId(asst);
    1386                                 }
    1387                                 typeParam = mutParam;
     1379                        mutType->forall.clear();
     1380                        mutType->assertions.clear();
     1381                        for (auto & typeParam : mutDecl->type_params) {
     1382                                symtab.addType(typeParam);
     1383                                mutType->forall.emplace_back(new ast::TypeInstType(typeParam->name, typeParam));
     1384                        }
     1385                        for (auto & asst : mutDecl->assertions) {
     1386                                asst = fixObjectType(asst.strict_as<ast::ObjectDecl>(), symtab);
     1387                                symtab.addId(asst);
     1388                                mutType->assertions.emplace_back(new ast::VariableExpr(functionDecl->location, asst));
    13881389                        }
    13891390
     
    14071408                        mutType->returns = std::move(returnTypes);
    14081409
     1410                        auto renamedType = strict_dynamic_cast<const ast::FunctionType *>(renameTyVars(mutType, RenameMode::GEN_EXPR_ID));
     1411
    14091412                        std::list<ast::ptr<ast::Stmt>> newStmts;
    14101413                        resolveWithExprs (mutDecl->withExprs, newStmts);
     
    14181421                        symtab.leaveScope();
    14191422
     1423                        mutDecl->type = renamedType;
    14201424                        mutDecl->mangleName = Mangle::mangle(mutDecl);
    14211425                        mutDecl->isTypeFixed = true;
     
    15341538        const PtrType * handlePtrType( const PtrType * type, const ast::SymbolTable & symtab ) {
    15351539                if ( type->dimension ) {
    1536                         #warning should use new equivalent to Validate::SizeType rather than sizeType here
    1537                         ast::ptr< ast::Type > sizeType = new ast::BasicType{ ast::BasicType::LongUnsignedInt };
     1540                        ast::ptr< ast::Type > sizeType = ast::sizeType;
    15381541                        ast::mutate_field(
    15391542                                type, &PtrType::dimension,
  • src/ResolvExpr/SatisfyAssertions.cpp

    r72a3aff r7a70fb2  
    6969        /// Reference to a single deferred item
    7070        struct DeferRef {
    71                 const ast::DeclWithType * decl;
     71                const ast::VariableExpr * expr;
    7272                const ast::AssertionSetValue & info;
    7373                const AssnCandidate & match;
     
    7777        /// Acts like an indexed list of DeferRef
    7878        struct DeferItem {
    79                 const ast::DeclWithType * decl;
     79                const ast::VariableExpr * expr;
    8080                const ast::AssertionSetValue & info;
    8181                AssnCandidateList matches;
    8282
    8383                DeferItem(
    84                         const ast::DeclWithType * d, const ast::AssertionSetValue & i, AssnCandidateList && ms )
    85                 : decl( d ), info( i ), matches( std::move( ms ) ) {}
     84                        const ast::VariableExpr * d, const ast::AssertionSetValue & i, AssnCandidateList && ms )
     85                : expr( d ), info( i ), matches( std::move( ms ) ) {}
    8686
    8787                bool empty() const { return matches.empty(); }
     
    8989                AssnCandidateList::size_type size() const { return matches.size(); }
    9090
    91                 DeferRef operator[] ( unsigned i ) const { return { decl, info, matches[i] }; }
     91                DeferRef operator[] ( unsigned i ) const { return { expr, info, matches[i] }; }
    9292        };
    9393
     
    138138        void addToSymbolTable( const ast::AssertionSet & have, ast::SymbolTable & symtab ) {
    139139                for ( auto & i : have ) {
    140                         if ( i.second.isUsed ) { symtab.addId( i.first ); }
     140                        if ( i.second.isUsed ) { symtab.addId( i.first->var ); }
    141141                }
    142142        }
     
    144144        /// Binds a single assertion, updating satisfaction state
    145145        void bindAssertion(
    146                 const ast::DeclWithType * decl, const ast::AssertionSetValue & info, CandidateRef & cand,
     146                const ast::VariableExpr * expr, const ast::AssertionSetValue & info, CandidateRef & cand,
    147147                AssnCandidate & match, InferCache & inferred
    148148        ) {
     
    156156
    157157                // place newly-inferred assertion in proper location in cache
    158                 inferred[ info.resnSlot ][ decl->uniqueId ] = ast::ParamEntry{
    159                         candidate->uniqueId, candidate, match.adjType, decl->get_type(), varExpr };
     158                inferred[ info.resnSlot ][ expr->var->uniqueId ] = ast::ParamEntry{
     159                        candidate->uniqueId, candidate, match.adjType, expr->result, varExpr };
    160160        }
    161161
     
    169169
    170170                std::vector<ast::SymbolTable::IdData> candidates;
    171                 auto kind = ast::SymbolTable::getSpecialFunctionKind(assn.first->name);
     171                auto kind = ast::SymbolTable::getSpecialFunctionKind(assn.first->var->name);
    172172                if (kind != ast::SymbolTable::SpecialFunctionKind::NUMBER_OF_KINDS) {
    173173                        // prefilter special decls by argument type, if already known
    174                         ast::ptr<ast::Type> thisArgType = strict_dynamic_cast<const ast::PointerType *>(assn.first->get_type())->base
     174                        ast::ptr<ast::Type> thisArgType = assn.first->result.strict_as<ast::PointerType>()->base
    175175                                .strict_as<ast::FunctionType>()->params[0]
    176176                                .strict_as<ast::ReferenceType>()->base;
     
    184184                }
    185185                else {
    186                         candidates = sat.symtab.lookupId(assn.first->name);
     186                        candidates = sat.symtab.lookupId(assn.first->var->name);
    187187                }
    188188                for ( const ast::SymbolTable::IdData & cdata : candidates ) {
     
    200200                        ast::TypeEnvironment newEnv{ sat.cand->env };
    201201                        ast::OpenVarSet newOpen{ sat.cand->open };
    202                         ast::ptr< ast::Type > toType = assn.first->get_type();
     202                        ast::ptr< ast::Type > toType = assn.first->result;
    203203                        ast::ptr< ast::Type > adjType =
    204204                                renameTyVars( adjustExprType( candidate->get_type(), newEnv, sat.symtab ) );
     
    337337                                        // compute conversion cost from satisfying decl to assertion
    338338                                        cost += computeConversionCost(
    339                                                 assn.match.adjType, assn.decl->get_type(), false, symtab, env );
     339                                                assn.match.adjType, assn.expr->result, false, symtab, env );
    340340
    341341                                        // mark vars+specialization on function-type assertions
     
    350350                                        cost.incVar( func->forall.size() );
    351351
    352                                         for ( const ast::TypeDecl * td : func->forall ) {
    353                                                 cost.decSpec( td->assertions.size() );
    354                                         }
     352                                        cost.decSpec( func->assertions.size() );
    355353                                }
    356354                        }
     
    451449                                ss << (tabs-1) << "Too many non-unique satisfying assignments for assertions:\n";
    452450                                for ( const auto & d : sat.deferred ) {
    453                                         ast::print( ss, d.decl, tabs );
     451                                        ast::print( ss, d.expr, tabs );
    454452                                }
    455453
     
    469467                                        ss << (tabs-1) << "No mutually-compatible satisfaction for assertions:\n";
    470468                                        for ( const auto& d : sat.deferred ) {
    471                                                 ast::print( ss, d.decl, tabs );
     469                                                ast::print( ss, d.expr, tabs );
    472470                                        }
    473471
     
    501499                                                nextNewNeed.insert( match.need.begin(), match.need.end() );
    502500
    503                                                 bindAssertion( r.decl, r.info, nextCand, match, nextInferred );
     501                                                bindAssertion( r.expr, r.info, nextCand, match, nextInferred );
    504502                                        }
    505503
  • src/ResolvExpr/Unify.cc

    r72a3aff r7a70fb2  
    773773
    774774                        const ast::Type * postvisit( const ast::TypeInstType * typeInst ) {
    775                                 if ( const ast::EqvClass * clz = tenv.lookup( typeInst->name ) ) {
     775                                if ( const ast::EqvClass * clz = tenv.lookup( *typeInst ) ) {
    776776                                        // expand ttype parameter into its actual type
    777777                                        if ( clz->data.kind == ast::TypeDecl::Ttype && clz->bound ) {
     
    888888                }
    889889
    890                 static void markAssertionSet( ast::AssertionSet & assns, const ast::DeclWithType * assn ) {
     890                static void markAssertionSet( ast::AssertionSet & assns, const ast::VariableExpr * assn ) {
    891891                        auto i = assns.find( assn );
    892892                        if ( i != assns.end() ) {
     
    900900                        const ast::FunctionType * type
    901901                ) {
    902                         for ( const auto & tyvar : type->forall ) {
    903                                 for ( const ast::DeclWithType * assert : tyvar->assertions ) {
    904                                         markAssertionSet( assn1, assert );
    905                                         markAssertionSet( assn2, assert );
    906                                 }
     902                        for ( auto & assert : type->assertions ) {
     903                                markAssertionSet( assn1, assert );
     904                                markAssertionSet( assn2, assert );
    907905                        }
    908906                }
     
    10301028
    10311029                void postvisit( const ast::TypeInstType * typeInst ) {
    1032                         assert( open.find( typeInst->name ) == open.end() );
     1030                        assert( open.find( *typeInst ) == open.end() );
    10331031                        handleRefType( typeInst, type2 );
    10341032                }
     
    11711169                auto var2 = dynamic_cast< const ast::TypeInstType * >( type2 );
    11721170                ast::OpenVarSet::const_iterator
    1173                         entry1 = var1 ? open.find( var1->name ) : open.end(),
    1174                         entry2 = var2 ? open.find( var2->name ) : open.end();
     1171                        entry1 = var1 ? open.find( *var1 ) : open.end(),
     1172                        entry2 = var2 ? open.find( *var2 ) : open.end();
    11751173                bool isopen1 = entry1 != open.end();
    11761174                bool isopen2 = entry2 != open.end();
  • src/SymTab/Mangler.cc

    r72a3aff r7a70fb2  
    671671                                        int dcount = 0, fcount = 0, vcount = 0, acount = 0;
    672672                                        mangleName += Encoding::forall;
    673                                         for ( const ast::TypeDecl * decl : ptype->forall ) {
     673                                        for ( auto & decl : ptype->forall ) {
    674674                                                switch ( decl->kind ) {
    675675                                                case ast::TypeDecl::Kind::Dtype:
     
    686686                                                } // switch
    687687                                                varNums[ decl->name ] = std::make_pair( nextVarNum, (int)decl->kind );
    688                                                 for ( const ast::DeclWithType * assert : decl->assertions ) {
    689                                                         ast::Pass<Mangler_new> sub_mangler(
    690                                                                 mangleOverridable, typeMode, mangleGenericParams, nextVarNum, varNums );
    691                                                         assert->accept( sub_mangler );
    692                                                         assertionNames.push_back( sub_mangler.core.get_mangleName() );
    693                                                         acount++;
    694                                                 } // for
     688                                        } // for
     689                                        for ( auto & assert : ptype->assertions ) {
     690                                                ast::Pass<Mangler_new> sub_mangler(
     691                                                        mangleOverridable, typeMode, mangleGenericParams, nextVarNum, varNums );
     692                                                assert->var->accept( sub_mangler );
     693                                                assertionNames.push_back( sub_mangler.core.get_mangleName() );
     694                                                acount++;
    695695                                        } // for
    696696                                        mangleName += std::to_string( dcount ) + "_" + std::to_string( fcount ) + "_" + std::to_string( vcount ) + "_" + std::to_string( acount ) + "_";
  • src/SymTab/Validate.cc

    r72a3aff r7a70fb2  
    14631463        }
    14641464
     1465        /*
     1466
    14651467        /// Associates forward declarations of aggregates with their definitions
    14661468        class LinkReferenceToTypes_new final
     
    18441846                }
    18451847        };
     1848        */
    18461849} // anonymous namespace
    18471850
     1851/*
    18481852const ast::Type * validateType(
    18491853                const CodeLocation & loc, const ast::Type * type, const ast::SymbolTable & symtab ) {
     
    18541858        return type->accept( lrt )->accept( fpd );
    18551859}
     1860*/
    18561861
    18571862} // namespace SymTab
  • src/Tuples/TupleAssignment.cc

    r72a3aff r7a70fb2  
    504504
    505505                        std::vector< ast::ptr< ast::Expr > > match() override {
    506                                 // temporary workaround for new and old ast to coexist and avoid name collision
    507                                 static UniqueName lhsNamer( "__massassign_Ln" );
    508                                 static UniqueName rhsNamer( "__massassign_Rn" );
     506                                static UniqueName lhsNamer( "__massassign_L" );
     507                                static UniqueName rhsNamer( "__massassign_R" );
    509508                                // empty tuple case falls into this matcher
    510509                                assert( lhs.empty() ? rhs.empty() : rhs.size() <= 1 );
     
    535534
    536535                        std::vector< ast::ptr< ast::Expr > > match() override {
    537                                 // temporary workaround for new and old ast to coexist and avoid name collision
    538                                 static UniqueName lhsNamer( "__multassign_Ln" );
    539                                 static UniqueName rhsNamer( "__multassign_Rn" );
     536                                static UniqueName lhsNamer( "__multassign_L" );
     537                                static UniqueName rhsNamer( "__multassign_R" );
    540538
    541539                                if ( lhs.size() != rhs.size() ) return {};
  • tests/.expect/KRfunctions.nast.x86.txt

    r72a3aff r7a70fb2  
    8686    __attribute__ ((unused)) signed int (*_X11_retval_f11PA0i_1)[];
    8787}
    88 signed int (*_X3f12FPA0A0i_iPiPi__1(signed int _X1ai_1, signed int *_X1bPi_1, signed int *_X1cPi_1))[][((unsigned long int )10)]{
    89     __attribute__ ((unused)) signed int (*_X11_retval_f12PA0A0i_1)[][((unsigned long int )10)];
     88signed int (*_X3f12FPA0A0i_iPiPi__1(signed int _X1ai_1, signed int *_X1bPi_1, signed int *_X1cPi_1))[][((unsigned int )10)]{
     89    __attribute__ ((unused)) signed int (*_X11_retval_f12PA0A0i_1)[][((unsigned int )10)];
    9090}
    91 signed int (*_X3f13FPA0A0i_iPiPi__1(signed int _X1ai_1, signed int *_X1bPi_1, signed int *_X1cPi_1))[][((unsigned long int )10)]{
    92     __attribute__ ((unused)) signed int (*_X11_retval_f13PA0A0i_1)[][((unsigned long int )10)];
     91signed int (*_X3f13FPA0A0i_iPiPi__1(signed int _X1ai_1, signed int *_X1bPi_1, signed int *_X1cPi_1))[][((unsigned int )10)]{
     92    __attribute__ ((unused)) signed int (*_X11_retval_f13PA0A0i_1)[][((unsigned int )10)];
    9393}
    94 signed int (*_X3f14FPA0A0i_iPiPi__1(signed int _X1ai_1, signed int *_X1bPi_1, signed int *_X1cPi_1))[][((unsigned long int )10)]{
    95     __attribute__ ((unused)) signed int (*_X11_retval_f14PA0A0i_1)[][((unsigned long int )10)];
     94signed int (*_X3f14FPA0A0i_iPiPi__1(signed int _X1ai_1, signed int *_X1bPi_1, signed int *_X1cPi_1))[][((unsigned int )10)]{
     95    __attribute__ ((unused)) signed int (*_X11_retval_f14PA0A0i_1)[][((unsigned int )10)];
    9696}
    9797signed int _X3f15Fi_iii__1(signed int _X1ai_1, signed int _X1bi_1, signed int _X1ci_1){
  • tests/.expect/attributes.nast.x86.txt

    r72a3aff r7a70fb2  
    623623__attribute__ ((used,used,used,used)) const signed int *_X3vd3PKi_1;
    624624__attribute__ ((used,used,unused,used,unused)) const signed int *_X3vd4PKi_1;
    625 __attribute__ ((used,used,used)) const signed int _X3vd5A0Ki_1[((unsigned long int )5)];
    626 __attribute__ ((used,used,unused,used)) const signed int _X3vd6A0Ki_1[((unsigned long int )5)];
     625__attribute__ ((used,used,used)) const signed int _X3vd5A0Ki_1[((unsigned int )5)];
     626__attribute__ ((used,used,unused,used)) const signed int _X3vd6A0Ki_1[((unsigned int )5)];
    627627__attribute__ ((used,used,used,used)) const signed int (*_X3vd7Fi___1)();
    628628__attribute__ ((used,used,unused,used,used)) const signed int (*_X3vd8Fi___1)();
     
    647647    __attribute__ ((unused,unused,used)) signed int _X2t1i_2;
    648648    __attribute__ ((unused,unused,unused,unused,unused)) signed int **_X2t2PPi_2;
    649     __attribute__ ((unused,unused,unused)) signed int _X2t3A0i_2[((unsigned long int )5)];
    650     __attribute__ ((unused,unused,unused,unused,unused)) signed int **_X2t4A0PPi_2[((unsigned long int )5)];
     649    __attribute__ ((unused,unused,unused)) signed int _X2t3A0i_2[((unsigned int )5)];
     650    __attribute__ ((unused,unused,unused,unused,unused)) signed int **_X2t4A0PPi_2[((unsigned int )5)];
    651651    __attribute__ ((unused,unused,unused)) signed int _X2t5Fi___2();
    652652    __attribute__ ((unused,unused,unused,unused)) signed int *_X2t6FPi___2();
     
    671671signed int _X4tpr2Fi_PPi__1(__attribute__ ((unused,unused,unused,unused,unused,unused)) signed int **_X3FooPPi_1);
    672672signed int _X4tpr3Fi_Pi__1(__attribute__ ((unused,unused,unused)) signed int *_X3FooPi_1);
    673 signed int _X4tpr4Fi_Fi_Pi___1(__attribute__ ((unused,unused)) signed int (*__anonymous_object1)(signed int __param_0[((unsigned long int )5)]));
     673signed int _X4tpr4Fi_Fi_Pi___1(__attribute__ ((unused,unused)) signed int (*__anonymous_object1)(signed int __param_0[((unsigned int )5)]));
    674674signed int _X4tpr5Fi_Fi____1(__attribute__ ((unused,unused,unused)) signed int (*_X3FooFi___1)());
    675675signed int _X4tpr6Fi_Fi____1(__attribute__ ((unused,unused,unused)) signed int (*_X3FooFi___1)());
     
    679679    __attribute__ ((used,unused)) signed int _X3ad1i_2;
    680680    __attribute__ ((unused,unused,unused)) signed int *_X3ad2Pi_2;
    681     __attribute__ ((unused,unused,unused)) signed int _X3ad3A0i_2[((unsigned long int )5)];
    682     __attribute__ ((unused,unused,unused,unused,unused)) signed int (*_X3ad4PA0i_2)[((unsigned long int )10)];
     681    __attribute__ ((unused,unused,unused)) signed int _X3ad3A0i_2[((unsigned int )5)];
     682    __attribute__ ((unused,unused,unused,unused,unused)) signed int (*_X3ad4PA0i_2)[((unsigned int )10)];
    683683    __attribute__ ((unused,unused,unused,unused,used)) signed int _X3ad5i_2;
    684684    __attribute__ ((unused,unused,unused,unused,unused)) signed int _X3ad6Fi___2();
  • tests/.expect/functions.nast.x86.txt

    r72a3aff r7a70fb2  
    4646    __attribute__ ((unused)) signed int (*_X11_retval_f10PA0i_1)[];
    4747}
    48 signed int (*_X3f11FPA0A0i___1())[][((unsigned long int )3)]{
    49     __attribute__ ((unused)) signed int (*_X11_retval_f11PA0A0i_1)[][((unsigned long int )3)];
    50 }
    51 signed int (*_X3f12FPA0A0i___1())[][((unsigned long int )3)]{
    52     __attribute__ ((unused)) signed int (*_X11_retval_f12PA0A0i_1)[][((unsigned long int )3)];
     48signed int (*_X3f11FPA0A0i___1())[][((unsigned int )3)]{
     49    __attribute__ ((unused)) signed int (*_X11_retval_f11PA0A0i_1)[][((unsigned int )3)];
     50}
     51signed int (*_X3f12FPA0A0i___1())[][((unsigned int )3)]{
     52    __attribute__ ((unused)) signed int (*_X11_retval_f12PA0A0i_1)[][((unsigned int )3)];
    5353}
    5454signed int _X4fII1Fi_i__1(signed int _X1ii_1){
     
    250250signed int _X1fFi_Fi_ii_Fi_i___1(__attribute__ ((unused)) signed int (*__anonymous_object20)(signed int __param_0, signed int __param_1), __attribute__ ((unused)) signed int (*__anonymous_object21)(signed int __param_0)){
    251251    __attribute__ ((unused)) signed int _X9_retval_fi_1;
    252     signed int (*(*_X2pcPA0A0PA0A0i_2)[][((unsigned long int )10)])[][((unsigned long int )3)];
    253     signed int (*(*_X1pPA0A0PA0A0i_2)[][((unsigned long int )10)])[][((unsigned long int )3)];
     252    signed int (*(*_X2pcPA0A0PA0A0i_2)[][((unsigned int )10)])[][((unsigned int )3)];
     253    signed int (*(*_X1pPA0A0PA0A0i_2)[][((unsigned int )10)])[][((unsigned int )3)];
    254254    signed int (*(*_X1pPA0Fi_i__2)[])(signed int __param_0);
    255255}
  • tests/errors/.expect/completeType.nast.x64.txt

    r72a3aff r7a70fb2  
    1212      Application of
    1313        Variable Expression: *?: forall
    14           DT: data type
     14          instance of type DT (not function type)
    1515          function
    1616        ... with parameters
     
    2121        ... with resolved type:
    2222          pointer to forall
    23             [unbound]:data type
     23            instance of type [unbound] (not function type)
    2424            function
    2525          ... with parameters
     
    4141    void
    4242  )
    43   Environment:([unbound]) -> instance of struct A without body (no widening)
     43  Environment:([unbound]DT) -> instance of struct A without body (no widening)
    4444
    4545
     
    4747      Application of
    4848        Variable Expression: *?: forall
    49           DT: data type
     49          instance of type DT (not function type)
    5050          function
    5151        ... with parameters
     
    5656        ... with resolved type:
    5757          pointer to forall
    58             [unbound]:data type
     58            instance of type [unbound] (not function type)
    5959            function
    6060          ... with parameters
     
    7676    void
    7777  )
    78   Environment:([unbound]) -> instance of struct B with body (no widening)
     78  Environment:([unbound]DT) -> instance of struct B with body (no widening)
    7979
    8080
     
    113113Cost ( 0, 1, 0, 0, 1, -5, 0 ): Application of
    114114            Variable Expression: baz: forall
    115               T: sized data type
    116               ... with assertions
    117                 ?=?: pointer to function
     115              instance of type T (not function type)
     116              with assertions
     117              Variable Expression: ?=?: pointer to function
     118              ... with parameters
     119                reference to instance of type T (not function type)
     120                instance of type T (not function type)
     121              ... returning
     122                instance of type T (not function type)
     123
     124              ... with resolved type:
     125                pointer to function
    118126                ... with parameters
    119127                  reference to instance of type T (not function type)
     
    122130                  instance of type T (not function type)
    123131
    124                 ?{}: pointer to function
    125                 ... with parameters
    126                   reference to instance of type T (not function type)
    127                 ... returning nothing
    128 
    129                 ?{}: pointer to function
    130                 ... with parameters
    131                   reference to instance of type T (not function type)
    132                   instance of type T (not function type)
    133                 ... returning nothing
    134 
    135                 ^?{}: pointer to function
    136                 ... with parameters
    137                   reference to instance of type T (not function type)
    138                 ... returning nothing
    139 
     132              Variable Expression: ?{}: pointer to function
     133              ... with parameters
     134                reference to instance of type T (not function type)
     135              ... returning nothing
     136
     137              ... with resolved type:
     138                pointer to function
     139                ... with parameters
     140                  reference to instance of type T (not function type)
     141                ... returning nothing
     142
     143              Variable Expression: ?{}: pointer to function
     144              ... with parameters
     145                reference to instance of type T (not function type)
     146                instance of type T (not function type)
     147              ... returning nothing
     148
     149              ... with resolved type:
     150                pointer to function
     151                ... with parameters
     152                  reference to instance of type T (not function type)
     153                  instance of type T (not function type)
     154                ... returning nothing
     155
     156              Variable Expression: ^?{}: pointer to function
     157              ... with parameters
     158                reference to instance of type T (not function type)
     159              ... returning nothing
     160
     161              ... with resolved type:
     162                pointer to function
     163                ... with parameters
     164                  reference to instance of type T (not function type)
     165                ... returning nothing
    140166
    141167              function
     
    146172            ... with resolved type:
    147173              pointer to forall
    148                 [unbound]:sized data type
    149                 ... with assertions
    150                   ?=?: pointer to function
     174                instance of type [unbound] (not function type)
     175                with assertions
     176                Variable Expression: ?=?: pointer to function
     177                ... with parameters
     178                  reference to instance of type T (not function type)
     179                  instance of type T (not function type)
     180                ... returning
     181                  instance of type T (not function type)
     182
     183                ... with resolved type:
     184                  pointer to function
    151185                  ... with parameters
    152186                    reference to instance of type [unbound] (not function type)
     
    155189                    instance of type [unbound] (not function type)
    156190
    157                   ?{}: pointer to function
     191                Variable Expression: ?{}: pointer to function
     192                ... with parameters
     193                  reference to instance of type T (not function type)
     194                ... returning nothing
     195
     196                ... with resolved type:
     197                  pointer to function
    158198                  ... with parameters
    159199                    reference to instance of type [unbound] (not function type)
    160200                  ... returning nothing
    161201
    162                   ?{}: pointer to function
     202                Variable Expression: ?{}: pointer to function
     203                ... with parameters
     204                  reference to instance of type T (not function type)
     205                  instance of type T (not function type)
     206                ... returning nothing
     207
     208                ... with resolved type:
     209                  pointer to function
    163210                  ... with parameters
    164211                    reference to instance of type [unbound] (not function type)
     
    166213                  ... returning nothing
    167214
    168                   ^?{}: pointer to function
     215                Variable Expression: ^?{}: pointer to function
     216                ... with parameters
     217                  reference to instance of type T (not function type)
     218                ... returning nothing
     219
     220                ... with resolved type:
     221                  pointer to function
    169222                  ... with parameters
    170223                    reference to instance of type [unbound] (not function type)
    171224                  ... returning nothing
    172 
    173225
    174226                function
     
    188240          void
    189241        )
    190         Environment:([unbound]) -> instance of type T (not function type) (no widening)
     242        Environment:([unbound]T) -> instance of type T (not function type) (no widening)
    191243
    192244      Could not satisfy assertion:
    193 ?=?: pointer to function
     245Variable Expression: ?=?: pointer to function
    194246        ... with parameters
    195           reference to instance of type [unbound] (not function type)
    196           instance of type [unbound] (not function type)
     247          reference to instance of type T (not function type)
     248          instance of type T (not function type)
    197249        ... returning
    198           instance of type [unbound] (not function type)
    199 
     250          instance of type T (not function type)
     251
     252        ... with resolved type:
     253          pointer to function
     254          ... with parameters
     255            reference to instance of type [unbound] (not function type)
     256            instance of type [unbound] (not function type)
     257          ... returning
     258            instance of type [unbound] (not function type)
     259
  • tests/errors/.expect/completeType.nast.x86.txt

    r72a3aff r7a70fb2  
    1212      Application of
    1313        Variable Expression: *?: forall
    14           DT: data type
     14          instance of type DT (not function type)
    1515          function
    1616        ... with parameters
     
    2121        ... with resolved type:
    2222          pointer to forall
    23             [unbound]:data type
     23            instance of type [unbound] (not function type)
    2424            function
    2525          ... with parameters
     
    4141    void
    4242  )
    43   Environment:([unbound]) -> instance of struct A without body (no widening)
     43  Environment:([unbound]DT) -> instance of struct A without body (no widening)
    4444
    4545
     
    4747      Application of
    4848        Variable Expression: *?: forall
    49           DT: data type
     49          instance of type DT (not function type)
    5050          function
    5151        ... with parameters
     
    5656        ... with resolved type:
    5757          pointer to forall
    58             [unbound]:data type
     58            instance of type [unbound] (not function type)
    5959            function
    6060          ... with parameters
     
    7676    void
    7777  )
    78   Environment:([unbound]) -> instance of struct B with body (no widening)
     78  Environment:([unbound]DT) -> instance of struct B with body (no widening)
    7979
    8080
     
    113113Cost ( 0, 1, 0, 0, 1, -5, 0 ): Application of
    114114            Variable Expression: baz: forall
    115               T: sized data type
    116               ... with assertions
    117                 ?=?: pointer to function
     115              instance of type T (not function type)
     116              with assertions
     117              Variable Expression: ?=?: pointer to function
     118              ... with parameters
     119                reference to instance of type T (not function type)
     120                instance of type T (not function type)
     121              ... returning
     122                instance of type T (not function type)
     123
     124              ... with resolved type:
     125                pointer to function
    118126                ... with parameters
    119127                  reference to instance of type T (not function type)
     
    122130                  instance of type T (not function type)
    123131
    124                 ?{}: pointer to function
    125                 ... with parameters
    126                   reference to instance of type T (not function type)
    127                 ... returning nothing
    128 
    129                 ?{}: pointer to function
    130                 ... with parameters
    131                   reference to instance of type T (not function type)
    132                   instance of type T (not function type)
    133                 ... returning nothing
    134 
    135                 ^?{}: pointer to function
    136                 ... with parameters
    137                   reference to instance of type T (not function type)
    138                 ... returning nothing
    139 
     132              Variable Expression: ?{}: pointer to function
     133              ... with parameters
     134                reference to instance of type T (not function type)
     135              ... returning nothing
     136
     137              ... with resolved type:
     138                pointer to function
     139                ... with parameters
     140                  reference to instance of type T (not function type)
     141                ... returning nothing
     142
     143              Variable Expression: ?{}: pointer to function
     144              ... with parameters
     145                reference to instance of type T (not function type)
     146                instance of type T (not function type)
     147              ... returning nothing
     148
     149              ... with resolved type:
     150                pointer to function
     151                ... with parameters
     152                  reference to instance of type T (not function type)
     153                  instance of type T (not function type)
     154                ... returning nothing
     155
     156              Variable Expression: ^?{}: pointer to function
     157              ... with parameters
     158                reference to instance of type T (not function type)
     159              ... returning nothing
     160
     161              ... with resolved type:
     162                pointer to function
     163                ... with parameters
     164                  reference to instance of type T (not function type)
     165                ... returning nothing
    140166
    141167              function
     
    146172            ... with resolved type:
    147173              pointer to forall
    148                 [unbound]:sized data type
    149                 ... with assertions
    150                   ?=?: pointer to function
     174                instance of type [unbound] (not function type)
     175                with assertions
     176                Variable Expression: ?=?: pointer to function
     177                ... with parameters
     178                  reference to instance of type T (not function type)
     179                  instance of type T (not function type)
     180                ... returning
     181                  instance of type T (not function type)
     182
     183                ... with resolved type:
     184                  pointer to function
    151185                  ... with parameters
    152186                    reference to instance of type [unbound] (not function type)
     
    155189                    instance of type [unbound] (not function type)
    156190
    157                   ?{}: pointer to function
     191                Variable Expression: ?{}: pointer to function
     192                ... with parameters
     193                  reference to instance of type T (not function type)
     194                ... returning nothing
     195
     196                ... with resolved type:
     197                  pointer to function
    158198                  ... with parameters
    159199                    reference to instance of type [unbound] (not function type)
    160200                  ... returning nothing
    161201
    162                   ?{}: pointer to function
     202                Variable Expression: ?{}: pointer to function
     203                ... with parameters
     204                  reference to instance of type T (not function type)
     205                  instance of type T (not function type)
     206                ... returning nothing
     207
     208                ... with resolved type:
     209                  pointer to function
    163210                  ... with parameters
    164211                    reference to instance of type [unbound] (not function type)
     
    166213                  ... returning nothing
    167214
    168                   ^?{}: pointer to function
     215                Variable Expression: ^?{}: pointer to function
     216                ... with parameters
     217                  reference to instance of type T (not function type)
     218                ... returning nothing
     219
     220                ... with resolved type:
     221                  pointer to function
    169222                  ... with parameters
    170223                    reference to instance of type [unbound] (not function type)
    171224                  ... returning nothing
    172 
    173225
    174226                function
     
    188240          void
    189241        )
    190         Environment:([unbound]) -> instance of type T (not function type) (no widening)
     242        Environment:([unbound]T) -> instance of type T (not function type) (no widening)
    191243
    192244      Could not satisfy assertion:
    193 ?=?: pointer to function
     245Variable Expression: ?=?: pointer to function
    194246        ... with parameters
    195           reference to instance of type [unbound] (not function type)
    196           instance of type [unbound] (not function type)
     247          reference to instance of type T (not function type)
     248          instance of type T (not function type)
    197249        ... returning
    198           instance of type [unbound] (not function type)
    199 
     250          instance of type T (not function type)
     251
     252        ... with resolved type:
     253          pointer to function
     254          ... with parameters
     255            reference to instance of type [unbound] (not function type)
     256            instance of type [unbound] (not function type)
     257          ... returning
     258            instance of type [unbound] (not function type)
     259
  • tests/heap.cfa

    r72a3aff r7a70fb2  
    1010// Created On       : Tue Nov  6 17:54:56 2018
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Sep 25 15:21:52 2020
    13 // Update Count     : 73
     12// Last Modified On : Tue Dec 15 12:11:51 2020
     13// Update Count     : 79
    1414//
    1515
     
    2727// }
    2828
    29 #define __U_DEFAULT_MMAP_START__ (512 * 1024 + 1)
    30 size_t default_mmap_start() __attribute__(( weak )) {
    31         return __U_DEFAULT_MMAP_START__;
     29size_t default_heap_expansion() {
     30        return 10 * 1024 * 1024;
     31} // default_heap_expansion
     32
     33size_t default_mmap_start() {
     34        return 512 * 1024 + 1;
    3235} // default_mmap_start
    3336
  • tests/multi_list.cfa

    r72a3aff r7a70fb2  
    1919}
    2020
     21TaskDL *& Back( TaskDL * n ) {
     22        return (TaskDL *)Back( (Seqable *)n );
     23}
     24
     25TaskDL *& Next( TaskDL * n ) {
     26        return (TaskDL *)Next( (Colable *)n );
     27}
     28
     29bool listed( TaskDL * n ) {
     30        return Next( (Colable *)n ) != 0p;
     31}
     32
    2133struct TaskSL {
    2234        inline Colable;
     
    2941Task & task( TaskSL & this ) with( this ) {                             // getter routine for containing node
    3042        return node;
     43}
     44
     45TaskSL *& Next( TaskSL * n ) {
     46        return (TaskSL *)Next( (Colable *)n );
     47}
     48
     49bool listed( TaskSL * n ) {
     50        return Next( (Colable *)n ) != 0p;
    3151}
    3252
  • tests/queue.cfa

    r72a3aff r7a70fb2  
    1313        void ?{}( Fred & fred, int p ) with( fred ) {
    1414                i = p;
     15        }
     16        Fred *& Next( Fred * n ) {
     17                return (Fred *)Next( (Colable *)n );
     18        }
     19
     20        bool listed( Fred * n ) {
     21                return Next( (Colable *)n ) != 0p;
    1522        }
    1623
     
    6875        }
    6976
     77        Mary *& Next( Mary * n ) {
     78                return (Mary *)Next( (Colable *)n );
     79        }
     80
     81        bool listed( Mary * n ) {
     82                return Next( (Colable *)n ) != 0p;
     83        }
     84
    7085        Queue(Mary) mary;
    7186        QueueIter(Mary) maryIter = { mary };
  • tests/raii/.expect/ctor-autogen-ERR1.nast.txt

    r72a3aff r7a70fb2  
    7070            ... with environment:
    7171              Types:
    72               Non-types:
    7372
    7473
  • tests/sequence.cfa

    r72a3aff r7a70fb2  
    1313        void ?{}( Fred & fred, int p ) with( fred ) {
    1414                i = p;
     15        }
     16
     17        Fred *& Back( Fred * n ) {
     18                return (Fred *)Back( (Seqable *)n );
     19        }
     20
     21        Fred *& Next( Fred * n ) {
     22                return (Fred *)Next( (Colable *)n );
     23        }
     24
     25        bool listed( Fred * n ) {
     26                return Next( (Colable *)n ) != 0p;
    1527        }
    1628
     
    7688        }
    7789
     90        Mary *& Back( Mary * n ) {
     91                return (Mary *)Back( (Seqable *)n );
     92        }
     93
     94        Mary *& Next( Mary * n ) {
     95                return (Mary *)Next( (Colable *)n );
     96        }
     97
     98        bool listed( Mary * n ) {
     99                return Next( (Colable *)n ) != 0p;
     100        }
     101
    78102        Sequence(Mary) mary;
    79103        Sequence(Mary) baz;
  • tests/stack.cfa

    r72a3aff r7a70fb2  
    1313        void ?{}( Fred & fred, int p ) with( fred ) {
    1414                i = p;
     15        }
     16        Fred *& Next( Fred * n ) {
     17                return (Fred *)Next( (Colable *)n );
     18        }
     19
     20        bool listed( Fred * n ) {
     21                return Next( (Colable *)n ) != 0p;
    1522        }
    1623
     
    6875        }
    6976
     77        Mary *& Next( Mary * n ) {
     78                return (Mary *)Next( (Colable *)n );
     79        }
     80
     81        bool listed( Mary * n ) {
     82                return Next( (Colable *)n ) != 0p;
     83        }
     84
    7085        Stack(Mary) mary;
    7186        StackIter(Mary) maryIter = { mary };
Note: See TracChangeset for help on using the changeset viewer.