Index: configure.ac =================================================================== --- configure.ac (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ configure.ac (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -24,4 +24,16 @@ #Trasforming cc1 will break compilation M4CFA_PROGRAM_NAME + +#============================================================================== +# New AST toggling support +AH_TEMPLATE([CFA_USE_NEW_AST],[Sets whether or not to use the new-ast, this is adefault value and can be overrided by --old-ast and --new-ast]) +AC_ARG_ENABLE(new-ast, + [ --enable-new-ast whether or not to use new ast as the default AST algorithm], + [case "${enableval}" in + yes) newast=true ;; + no) newast=false ;; + *) AC_MSG_ERROR([bad value ${enableval} for --enable-new-ast]) ;; + esac],[newast=false]) +AC_DEFINE_UNQUOTED([CFA_USE_NEW_AST], $newast) #============================================================================== Index: driver/cc1.cc =================================================================== --- driver/cc1.cc (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ driver/cc1.cc (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -10,6 +10,6 @@ // Created On : Fri Aug 26 14:23:51 2005 // Last Modified By : Peter A. Buhr -// Last Modified On : Sat May 30 18:09:05 2020 -// Update Count : 404 +// Last Modified On : Thu Aug 13 21:03:15 2020 +// Update Count : 407 // @@ -170,5 +170,5 @@ if ( arg == "-quiet" ) { } else if ( arg == "-imultilib" || arg == "-imultiarch" ) { - i += 1; // and the argument + i += 1; // and argument } else if ( prefix( arg, "-A" ) ) { } else if ( prefix( arg, "-D__GNU" ) ) { @@ -177,5 +177,5 @@ //******** } else if ( arg == "-D" && prefix( argv[i + 1], "__GNU" ) ) { - i += 1; // and the argument + i += 1; // and argument // strip flags controlling cpp step @@ -184,5 +184,5 @@ cpp_flag = true; } else if ( arg == "-D" && string( argv[i + 1] ) == "__CPP__" ) { - i += 1; // and the argument + i += 1; // and argument cpp_flag = true; @@ -194,5 +194,5 @@ cpp_out = argv[i]; } else { - args[nargs++] = argv[i]; // pass the flag along + args[nargs++] = argv[i]; // pass flag along // CPP flags with an argument if ( arg == "-D" || arg == "-U" || arg == "-I" || arg == "-MF" || arg == "-MT" || arg == "-MQ" || @@ -200,12 +200,14 @@ arg == "-iwithprefix" || arg == "-iwithprefixbefore" || arg == "-isystem" || arg == "-isysroot" ) { i += 1; - args[nargs++] = argv[i]; // pass the argument along + args[nargs++] = argv[i]; // pass argument along #ifdef __DEBUG_H__ cerr << "argv[" << i << "]:\"" << argv[i] << "\"" << endl; #endif // __DEBUG_H__ } else if ( arg == "-MD" || arg == "-MMD" ) { + // gcc frontend generates the dependency file-name after the -MD/-MMD flag, but it is necessary to + // prefix that file name with -MF. args[nargs++] = "-MF"; // insert before file i += 1; - args[nargs++] = argv[i]; // pass the argument along + args[nargs++] = argv[i]; // pass argument along #ifdef __DEBUG_H__ cerr << "argv[" << i << "]:\"" << argv[i] << "\"" << endl; @@ -279,5 +281,5 @@ // Run the C preprocessor and save the output in the given file. - if ( fork() == 0 ) { // child process ? + if ( fork() == 0 ) { // child process ? // -o xxx.ii cannot be used to write the output file from cpp because no output file is created if cpp detects // an error (e.g., cannot find include file). Whereas, output is always generated, even when there is an error, @@ -388,9 +390,9 @@ } else { - args[nargs++] = argv[i]; // pass the flag along + args[nargs++] = argv[i]; // pass flag along if ( arg == "-o" ) { i += 1; cpp_out = argv[i]; - args[nargs++] = argv[i]; // pass the argument along + args[nargs++] = argv[i]; // pass argument along #ifdef __DEBUG_H__ cerr << "arg:\"" << argv[i] << "\"" << endl; Index: driver/cfa.cc =================================================================== --- driver/cfa.cc (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ driver/cfa.cc (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -10,6 +10,6 @@ // Created On : Tue Aug 20 13:44:49 2002 // Last Modified By : Peter A. Buhr -// Last Modified On : Sat May 30 18:28:23 2020 -// Update Count : 433 +// Last Modified On : Thu Aug 13 17:22:02 2020 +// Update Count : 435 // @@ -180,26 +180,19 @@ if ( arg == "-Xlinker" || arg == "-o" ) { - args[nargs++] = argv[i]; // pass argument along + args[nargs++] = argv[i]; // pass flag along i += 1; if ( i == argc ) continue; // next argument available ? args[nargs++] = argv[i]; // pass argument along if ( arg == "-o" ) o_file = i; // remember file - } else if ( strncmp(arg.c_str(), "-XCFA", 5) == 0 ) { // CFA pass through - if(arg.size() == 5) { + } else if ( strncmp(arg.c_str(), "-XCFA", 5) == 0 ) { // CFA pass through + if ( arg.size() == 5 ) { i += 1; - if ( i == argc ) continue; // next argument available ? + if ( i == argc ) continue; // next argument available ? Putenv( argv, argv[i] ); - - // CFA specific arguments - } - else if(arg[5] == ',') { + } else if ( arg[5] == ',' ) { // CFA specific arguments Putenv( argv, argv[i] + 6 ); - - // CFA specific arguments - } - else { + } else { // CFA specific arguments args[nargs++] = argv[i]; - } - + } // if } else if ( arg == "-CFA" ) { CFA_flag = true; // strip the -CFA flag @@ -235,14 +228,14 @@ } else if ( arg == "-v" ) { verbose = true; // verbosity required - args[nargs++] = argv[i]; // pass argument along + args[nargs++] = argv[i]; // pass flag along } else if ( arg == "-g" ) { debugging = true; // symbolic debugging required - args[nargs++] = argv[i]; // pass argument along + args[nargs++] = argv[i]; // pass flag along } else if ( arg == "-save-temps" ) { - args[nargs++] = argv[i]; // pass argument along + args[nargs++] = argv[i]; // pass flag along Putenv( argv, arg ); // save cfa-cpp output } else if ( prefix( arg, "-x" ) ) { // file suffix ? string lang; - args[nargs++] = argv[i]; // pass argument along + args[nargs++] = argv[i]; // pass flag along if ( arg.length() == 2 ) { // separate argument ? i += 1; @@ -261,11 +254,11 @@ } else if ( prefix( arg, "-std=" ) || prefix( arg, "--std=" ) ) { std_flag = true; // -std=XX provided - args[nargs++] = argv[i]; // pass argument along + args[nargs++] = argv[i]; // pass flag along } else if ( arg == "-w" ) { - args[nargs++] = argv[i]; // pass argument along + args[nargs++] = argv[i]; // pass flag along Putenv( argv, arg ); } else if ( prefix( arg, "-W" ) ) { // check before next tests if ( arg == "-Werror" || arg == "-Wall" ) { - args[nargs++] = argv[i]; // pass argument along + args[nargs++] = argv[i]; // pass flag along Putenv( argv, argv[i] ); } else { @@ -281,9 +274,15 @@ bprefix = arg.substr(2); // strip the -B flag } else if ( arg == "-c" || arg == "-S" || arg == "-E" || arg == "-M" || arg == "-MM" ) { - args[nargs++] = argv[i]; // pass argument along + args[nargs++] = argv[i]; // pass flag along if ( arg == "-E" || arg == "-M" || arg == "-MM" ) { cpp_flag = true; // cpp only } // if link = false; // no linkage required + } else if ( arg == "-D" || arg == "-U" || arg == "-I" || arg == "-MF" || arg == "-MT" || arg == "-MQ" || + arg == "-include" || arg == "-imacros" || arg == "-idirafter" || arg == "-iprefix" || + arg == "-iwithprefix" || arg == "-iwithprefixbefore" || arg == "-isystem" || arg == "-isysroot" ) { + args[nargs++] = argv[i]; // pass flag along + i += 1; + args[nargs++] = argv[i]; // pass argument along } else if ( arg[1] == 'l' ) { // if the user specifies a library, load it after user code Index: libcfa/src/Makefile.am =================================================================== --- libcfa/src/Makefile.am (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ libcfa/src/Makefile.am (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -44,5 +44,5 @@ headers = common.hfa fstream.hfa heap.hfa iostream.hfa iterator.hfa limits.hfa rational.hfa \ - time.hfa stdlib.hfa memory.hfa parseargs.hfa \ + time.hfa stdlib.hfa parseargs.hfa \ containers/maybe.hfa containers/pair.hfa containers/result.hfa containers/vector.hfa Index: libcfa/src/concurrency/invoke.h =================================================================== --- libcfa/src/concurrency/invoke.h (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ libcfa/src/concurrency/invoke.h (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -26,4 +26,11 @@ #ifndef _INVOKE_H_ #define _INVOKE_H_ + + struct __cfaehm_try_resume_node; + struct __cfaehm_base_exception_t; + struct exception_context_t { + struct __cfaehm_try_resume_node * top_resume; + struct __cfaehm_base_exception_t * current_exception; + }; struct __stack_context_t { @@ -51,4 +58,7 @@ // base of stack void * base; + + // Information for exception handling. + struct exception_context_t exception_context; }; @@ -84,5 +94,7 @@ }; - static inline struct __stack_t * __get_stack( struct $coroutine * cor ) { return (struct __stack_t*)(((uintptr_t)cor->stack.storage) & ((uintptr_t)-2)); } + static inline struct __stack_t * __get_stack( struct $coroutine * cor ) { + return (struct __stack_t*)(((uintptr_t)cor->stack.storage) & ((uintptr_t)-2)); + } // struct which calls the monitor is accepting Index: libcfa/src/concurrency/kernel/startup.cfa =================================================================== --- libcfa/src/concurrency/kernel/startup.cfa (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ libcfa/src/concurrency/kernel/startup.cfa (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -516,5 +516,8 @@ ( this.terminated ){ 0 }; ( this.runner ){}; - init( this, name, _cltr ); + + disable_interrupts(); + init( this, name, _cltr ); + enable_interrupts( __cfaabi_dbg_ctx ); __cfadbg_print_safe(runtime_core, "Kernel : Starting core %p\n", &this); @@ -540,5 +543,7 @@ free( this.stack ); - deinit( this ); + disable_interrupts(); + deinit( this ); + enable_interrupts( __cfaabi_dbg_ctx ); } Index: libcfa/src/concurrency/ready_queue.cfa =================================================================== --- libcfa/src/concurrency/ready_queue.cfa (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ libcfa/src/concurrency/ready_queue.cfa (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -150,4 +150,6 @@ // queues or removing them. uint_fast32_t ready_mutate_lock( void ) with(*__scheduler_lock) { + /* paranoid */ verify( ! kernelTLS.preemption_state.enabled ); + // Step 1 : lock global lock // It is needed to avoid processors that register mid Critical-Section @@ -164,8 +166,11 @@ } + /* paranoid */ verify( ! kernelTLS.preemption_state.enabled ); return s; } void ready_mutate_unlock( uint_fast32_t last_s ) with(*__scheduler_lock) { + /* paranoid */ verify( ! kernelTLS.preemption_state.enabled ); + // Step 1 : release local locks // This must be done while the global lock is held to avoid @@ -182,4 +187,6 @@ /*paranoid*/ assert(true == lock); __atomic_store_n(&lock, (bool)false, __ATOMIC_RELEASE); + + /* paranoid */ verify( ! kernelTLS.preemption_state.enabled ); } @@ -419,6 +426,5 @@ // Actually pop the list struct $thread * thrd; - bool emptied; - [thrd, emptied] = pop(lane); + thrd = pop(lane); /* paranoid */ verify(thrd); @@ -457,6 +463,5 @@ if(head(lane)->link.next == thrd) { $thread * pthrd; - bool emptied; - [pthrd, emptied] = pop(lane); + pthrd = pop(lane); /* paranoid */ verify( pthrd == thrd ); @@ -608,6 +613,5 @@ while(!is_empty(lanes.data[idx])) { struct $thread * thrd; - __attribute__((unused)) bool _; - [thrd, _] = pop(lanes.data[idx]); + thrd = pop(lanes.data[idx]); push(cltr, thrd); Index: libcfa/src/concurrency/ready_subqueue.hfa =================================================================== --- libcfa/src/concurrency/ready_subqueue.hfa (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ libcfa/src/concurrency/ready_subqueue.hfa (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -144,5 +144,5 @@ // returns popped // returns true of lane was empty before push, false otherwise -[$thread *, bool] pop(__intrusive_lane_t & this) { +$thread * pop(__intrusive_lane_t & this) { /* paranoid */ verify(this.lock); /* paranoid */ verify(this.before.link.ts != 0ul); @@ -162,5 +162,6 @@ head->link.next = next; next->link.prev = head; - node->link.[next, prev] = 0p; + node->link.next = 0p; + node->link.prev = 0p; // Update head time stamp @@ -180,5 +181,5 @@ /* paranoid */ verify(tail(this)->link.prev == head(this)); /* paranoid */ verify(head(this)->link.next == tail(this)); - return [node, true]; + return node; } else { @@ -187,5 +188,5 @@ /* paranoid */ verify(head(this)->link.next != tail(this)); /* paranoid */ verify(this.before.link.ts != 0); - return [node, false]; + return node; } } Index: libcfa/src/exception.c =================================================================== --- libcfa/src/exception.c (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ libcfa/src/exception.c (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -10,6 +10,6 @@ // Created On : Mon Jun 26 15:13:00 2017 // Last Modified By : Andrew Beach -// Last Modified On : Thr May 21 12:18:00 2020 -// Update Count : 20 +// Last Modified On : Wed Aug 12 13:55:00 2020 +// Update Count : 21 // @@ -28,4 +28,5 @@ #include #include +#include "concurrency/invoke.h" #include "stdhdr/assert.h" @@ -59,10 +60,5 @@ // Temperary global exception context. Does not work with concurency. -struct exception_context_t { - struct __cfaehm_try_resume_node * top_resume; - - exception_t * current_exception; - int current_handler_index; -} static shared_stack = {NULL, NULL, 0}; +static struct exception_context_t shared_stack = {NULL, NULL}; // Get the current exception context. @@ -122,4 +118,15 @@ // MEMORY MANAGEMENT ========================================================= + +struct __cfaehm_node { + struct _Unwind_Exception unwind_exception; + struct __cfaehm_node * next; + int handler_index; +}; + +#define NODE_TO_EXCEPT(node) ((exception_t *)(1 + (node))) +#define EXCEPT_TO_NODE(except) ((struct __cfaehm_node *)(except) - 1) +#define UNWIND_TO_NODE(unwind) ((struct __cfaehm_node *)(unwind)) +#define NULL_MAP(map, ptr) ((ptr) ? (map(ptr)) : NULL) // How to clean up an exception in various situations. @@ -137,15 +144,4 @@ } -// We need a piece of storage to raise the exception, for now its a single -// piece. -static struct _Unwind_Exception this_exception_storage; - -struct __cfaehm_node { - struct __cfaehm_node * next; -}; - -#define NODE_TO_EXCEPT(node) ((exception_t *)(1 + (node))) -#define EXCEPT_TO_NODE(except) ((struct __cfaehm_node *)(except) - 1) - // Creates a copy of the indicated exception and sets current_exception to it. static void __cfaehm_allocate_exception( exception_t * except ) { @@ -161,14 +157,14 @@ } + // Initialize the node: + exception_t * except_store = NODE_TO_EXCEPT(store); + store->unwind_exception.exception_class = __cfaehm_exception_class; + store->unwind_exception.exception_cleanup = __cfaehm_exception_cleanup; + store->handler_index = 0; + except->virtual_table->copy( except_store, except ); + // Add the node to the list: - store->next = EXCEPT_TO_NODE(context->current_exception); - context->current_exception = NODE_TO_EXCEPT(store); - - // Copy the exception to storage. - except->virtual_table->copy( context->current_exception, except ); - - // Set up the exception storage. - this_exception_storage.exception_class = __cfaehm_exception_class; - this_exception_storage.exception_cleanup = __cfaehm_exception_cleanup; + store->next = NULL_MAP(EXCEPT_TO_NODE, context->current_exception); + context->current_exception = except_store; } @@ -185,5 +181,5 @@ if ( context->current_exception == except ) { node = to_free->next; - context->current_exception = (node) ? NODE_TO_EXCEPT(node) : 0; + context->current_exception = NULL_MAP(NODE_TO_EXCEPT, node); } else { node = EXCEPT_TO_NODE(context->current_exception); @@ -213,5 +209,5 @@ // Verify actions follow the rules we expect. verify((actions & _UA_CLEANUP_PHASE) && (actions & _UA_FORCE_UNWIND)); - verify(!(actions & (_UA_SEARCH_PHASE | _UA_HANDER_FRAME))); + verify(!(actions & (_UA_SEARCH_PHASE | _UA_HANDLER_FRAME))); if ( actions & _UA_END_OF_STACK ) { @@ -222,9 +218,11 @@ } +static struct _Unwind_Exception cancel_exception_storage; + // Cancel the current stack, prefroming approprate clean-up and messaging. void __cfaehm_cancel_stack( exception_t * exception ) { // TODO: Detect current stack and pick a particular stop-function. _Unwind_Reason_Code ret; - ret = _Unwind_ForcedUnwind( &this_exception_storage, _Stop_Fn, (void*)0x22 ); + ret = _Unwind_ForcedUnwind( &cancel_exception_storage, _Stop_Fn, (void*)0x22 ); printf("UNWIND ERROR %d after force unwind\n", ret); abort(); @@ -247,9 +245,10 @@ static void __cfaehm_begin_unwind(void(*defaultHandler)(exception_t *)) { struct exception_context_t * context = this_exception_context(); - struct _Unwind_Exception * storage = &this_exception_storage; if ( NULL == context->current_exception ) { printf("UNWIND ERROR missing exception in begin unwind\n"); abort(); } + struct _Unwind_Exception * storage = + &EXCEPT_TO_NODE(context->current_exception)->unwind_exception; // Call stdlibc to raise the exception @@ -419,5 +418,5 @@ _Unwind_Reason_Code ret = (0 == index) ? _URC_CONTINUE_UNWIND : _URC_HANDLER_FOUND; - context->current_handler_index = index; + UNWIND_TO_NODE(unwind_exception)->handler_index = index; // Based on the return value, check if we matched the exception @@ -425,4 +424,5 @@ __cfadbg_print_safe(exception, " handler found\n"); } else { + // TODO: Continue the search if there is more in the table. __cfadbg_print_safe(exception, " no handler\n"); } @@ -516,5 +516,5 @@ // Exception handler // Note: Saving the exception context on the stack breaks termination exceptions. - catch_block( this_exception_context()->current_handler_index, + catch_block( EXCEPT_TO_NODE( this_exception_context()->current_exception )->handler_index, this_exception_context()->current_exception ); } Index: libcfa/src/iostream.cfa =================================================================== --- libcfa/src/iostream.cfa (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ libcfa/src/iostream.cfa (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -10,6 +10,6 @@ // Created On : Wed May 27 17:56:53 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon Aug 10 09:32:14 2020 -// Update Count : 1126 +// Last Modified On : Tue Aug 11 22:16:33 2020 +// Update Count : 1128 // @@ -37,22 +37,4 @@ forall( dtype ostype | ostream( ostype ) ) { - ostype & ?|?( ostype & os, zero_t ) { - if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) ); - fmt( os, "%d", 0n ); - return os; - } // ?|? - void ?|?( ostype & os, zero_t z ) { - (ostype &)(os | z); ends( os ); - } // ?|? - - ostype & ?|?( ostype & os, one_t ) { - if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) ); - fmt( os, "%d", 1n ); - return os; - } // ?|? - void ?|?( ostype & os, one_t o ) { - (ostype &)(os | o); ends( os ); - } // ?|? - ostype & ?|?( ostype & os, bool b ) { if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) ); Index: libcfa/src/iostream.hfa =================================================================== --- libcfa/src/iostream.hfa (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ libcfa/src/iostream.hfa (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -10,6 +10,6 @@ // Created On : Wed May 27 17:56:53 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Jul 16 07:43:32 2020 -// Update Count : 348 +// Last Modified On : Tue Aug 11 22:16:14 2020 +// Update Count : 350 // @@ -67,9 +67,4 @@ forall( dtype ostype | ostream( ostype ) ) { - ostype & ?|?( ostype &, zero_t ); - void ?|?( ostype &, zero_t ); - ostype & ?|?( ostype &, one_t ); - void ?|?( ostype &, one_t ); - ostype & ?|?( ostype &, bool ); void ?|?( ostype &, bool ); Index: libcfa/src/stdlib.hfa =================================================================== --- libcfa/src/stdlib.hfa (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ libcfa/src/stdlib.hfa (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -10,6 +10,6 @@ // Created On : Thu Jan 28 17:12:35 2016 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Jul 30 16:14:58 2020 -// Update Count : 490 +// Last Modified On : Tue Aug 11 21:11:46 2020 +// Update Count : 495 // @@ -136,23 +136,23 @@ T * alloc_set( char fill ) { return (T *)memset( (T *)alloc(), (int)fill, sizeof(T) ); // initialize with fill value - } // alloc - - T * alloc_set( T fill ) { + } // alloc_set + + T * alloc_set( const T & fill ) { return (T *)memcpy( (T *)alloc(), &fill, sizeof(T) ); // initialize with fill value - } // alloc + } // alloc_set T * alloc_set( size_t dim, char fill ) { return (T *)memset( (T *)alloc( dim ), (int)fill, dim * sizeof(T) ); // initialize with fill value - } // alloc - - T * alloc_set( size_t dim, T fill ) { + } // alloc_set + + T * alloc_set( size_t dim, const T & fill ) { T * r = (T *)alloc( dim ); for ( i; dim ) { memcpy( &r[i], &fill, sizeof(T) ); } // initialize with fill value return r; - } // alloc + } // alloc_set T * alloc_set( size_t dim, const T fill[] ) { return (T *)memcpy( (T *)alloc( dim ), fill, dim * sizeof(T) ); // initialize with fill value - } // alloc + } // alloc_set T * alloc_set( T ptr[], size_t dim, char fill ) { // realloc array with fill @@ -166,5 +166,5 @@ } // alloc_set - T * alloc_set( T ptr[], size_t dim, T & fill ) { // realloc array with fill + T * alloc_set( T ptr[], size_t dim, const T & fill ) { // realloc array with fill size_t odim = malloc_size( ptr ) / sizeof(T); // current dimension size_t nsize = dim * sizeof(T); // new allocation @@ -177,5 +177,5 @@ } // if return nptr; - } // alloc_align_set + } // alloc_set } // distribution @@ -204,23 +204,23 @@ T * alloc_align_set( size_t align, char fill ) { return (T *)memset( (T *)alloc_align( align ), (int)fill, sizeof(T) ); // initialize with fill value - } // alloc_align - - T * alloc_align_set( size_t align, T fill ) { + } // alloc_align_set + + T * alloc_align_set( size_t align, const T & fill ) { return (T *)memcpy( (T *)alloc_align( align ), &fill, sizeof(T) ); // initialize with fill value - } // alloc_align + } // alloc_align_set T * alloc_align_set( size_t align, size_t dim, char fill ) { return (T *)memset( (T *)alloc_align( align, dim ), (int)fill, dim * sizeof(T) ); // initialize with fill value - } // alloc_align - - T * alloc_align_set( size_t align, size_t dim, T fill ) { + } // alloc_align_set + + T * alloc_align_set( size_t align, size_t dim, const T & fill ) { T * r = (T *)alloc_align( align, dim ); for ( i; dim ) { memcpy( &r[i], &fill, sizeof(T) ); } // initialize with fill value return r; - } // alloc_align + } // alloc_align_set T * alloc_align_set( size_t align, size_t dim, const T fill[] ) { return (T *)memcpy( (T *)alloc_align( align, dim ), fill, dim * sizeof(T) ); - } // alloc_align + } // alloc_align_set T * alloc_align_set( T ptr[], size_t align, size_t dim, char fill ) { @@ -234,5 +234,5 @@ } // alloc_align_set - T * alloc_align_set( T ptr[], size_t align, size_t dim, T & fill ) { + T * alloc_align_set( T ptr[], size_t align, size_t dim, const T & fill ) { size_t odim = malloc_size( ptr ) / sizeof(T); // current dimension size_t nsize = dim * sizeof(T); // new allocation Index: src/AST/Attribute.hpp =================================================================== --- src/AST/Attribute.hpp (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/AST/Attribute.hpp (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -51,4 +51,6 @@ template friend node_t * mutate(const node_t * node); + template + friend node_t * shallowCopy(const node_t * node); }; Index: src/AST/CVQualifiers.hpp =================================================================== --- src/AST/CVQualifiers.hpp (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/AST/CVQualifiers.hpp (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -27,12 +27,11 @@ Restrict = 1 << 1, Volatile = 1 << 2, - Lvalue = 1 << 3, - Mutex = 1 << 4, - Atomic = 1 << 5, - NumQualifiers = 6 + Mutex = 1 << 3, + Atomic = 1 << 4, + NumQualifiers = 5 }; /// Mask for equivalence-preserving qualfiers - enum { EquivQualifiers = ~(Restrict | Lvalue) }; + enum { EquivQualifiers = ~Restrict }; /// Underlying data for qualifiers @@ -44,5 +43,4 @@ bool is_restrict : 1; bool is_volatile : 1; - bool is_lvalue : 1; bool is_mutex : 1; bool is_atomic : 1; Index: src/AST/Convert.cpp =================================================================== --- src/AST/Convert.cpp (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/AST/Convert.cpp (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -20,4 +20,5 @@ #include "AST/Attribute.hpp" +#include "AST/Copy.hpp" #include "AST/Decl.hpp" #include "AST/Expr.hpp" @@ -587,5 +588,5 @@ assert( tgtResnSlots.empty() ); - if ( srcInferred.mode == ast::Expr::InferUnion::Params ) { + if ( srcInferred.data.inferParams ) { const ast::InferredParams &srcParams = srcInferred.inferParams(); for (auto & srcParam : srcParams) { @@ -593,11 +594,12 @@ srcParam.second.decl, get().accept1(srcParam.second.declptr), - get().accept1(srcParam.second.actualType), - get().accept1(srcParam.second.formalType), - get().accept1(srcParam.second.expr) + get().accept1(srcParam.second.actualType)->clone(), + get().accept1(srcParam.second.formalType)->clone(), + get().accept1(srcParam.second.expr)->clone() )); assert(res.second); } - } else if ( srcInferred.mode == ast::Expr::InferUnion::Slots ) { + } + if ( srcInferred.data.resnSlots ) { const ast::ResnSlots &srcSlots = srcInferred.resnSlots(); for (auto srcSlot : srcSlots) { @@ -620,4 +622,15 @@ tgt->result = get().accept1(src->result); + // Unconditionally use a clone of the result type. + // We know this will leak some objects: much of the immediate conversion result. + // In some cases, using the conversion result directly gives unintended object sharing. + // A parameter (ObjectDecl, a child of a FunctionType) is shared by the weak-ref cache. + // But tgt->result must be fully owned privately by tgt. + // Applying these conservative copies here means + // - weak references point at the declaration's copy, not these expr.result copies (good) + // - we copy more objects than really needed (bad, tolerated) + if (tgt->result) { + tgt->result = tgt->result->clone(); + } return visitBaseExpr_skipResultType(src, tgt); } @@ -979,6 +992,11 @@ const ast::Expr * visit( const ast::StmtExpr * node ) override final { + auto stmts = node->stmts; + // disable sharing between multiple StmtExprs explicitly. + if (inCache(stmts)) { + stmts = ast::deepCopy(stmts.get()); + } auto rslt = new StmtExpr( - get().accept1(node->stmts) + get().accept1(stmts) ); @@ -1986,5 +2004,5 @@ assert( oldInferParams.empty() || oldResnSlots.empty() ); - assert( newInferred.mode == ast::Expr::InferUnion::Empty ); + // assert( newInferred.mode == ast::Expr::InferUnion::Empty ); if ( !oldInferParams.empty() ) { @@ -2117,5 +2135,6 @@ old->location, GET_ACCEPT_1(member, DeclWithType), - GET_ACCEPT_1(aggregate, Expr) + GET_ACCEPT_1(aggregate, Expr), + ast::MemberExpr::NoOpConstructionChosen ) ); Index: src/AST/Copy.hpp =================================================================== --- src/AST/Copy.hpp (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) +++ src/AST/Copy.hpp (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -0,0 +1,133 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// Copy.hpp -- Provides functions to copy the AST. +// +// Author : Andrew Beach +// Created On : Wed Jul 10 16:13:00 2019 +// Last Modified By : Andrew Beach +// Last Modified On : Fri Jun 19 16:43:00 2020 +// Update Count : 1 +// + +#pragma once + +#include "Decl.hpp" +#include "Expr.hpp" +#include "Pass.hpp" +#include "Stmt.hpp" +#include "Type.hpp" + +namespace ast { + +template +node_t * shallowCopy( const node_t * node ); +/* Create a shallow copy of the node given. + * + * The new node has all the same primitive field values and points to the + * same children nodes as the parent. + */ + +template +node_t * deepCopy( const node_t * localRoot ); +/* Create a deep copy of the tree rooted at localRoot. + * + * This creates a copy of every node in the sub-tree (reachable by strong + * reference from local_root) and updates any readonly pointers on those nodes + * that point to another node in the sub-tree to the new version of that node. + */ + +class DeepCopyCore { + std::unordered_map< const Node *, const Node * > nodeCache; + std::unordered_set< readonly * > readonlyCache; + + template + void readonlyInsert( const readonly * ptrptr ) { + readonlyCache.insert( (readonly *) ptrptr ); + } + +public: + template + const node_t * previsit( const node_t * node ) { + const node_t * copy = shallowCopy( node ); + nodeCache.insert( std::make_pair( node, copy ) ); + return copy; + } + + void postvisit( const AggregateDecl * node ) { + readonlyInsert( &node->parent ); + } + + void postvisit( const StructInstType * node ) { + readonlyInsert( &node->base ); + } + + void postvisit( const UnionInstType * node ) { + readonlyInsert( &node->base ); + } + + void postvisit( const EnumInstType * node ) { + readonlyInsert( &node->base ); + } + + void postvisit( const TraitInstType * node ) { + readonlyInsert( &node->base ); + } + + void postvisit( const TypeInstType * node ) { + readonlyInsert( &node->base ); + } + + void postvisit( const ImplicitCtorDtorStmt * node ) { + readonlyInsert( (const readonly *) &node->callStmt ); + } + + void postvisit( const MemberExpr * node ) { + readonlyInsert( &node->member ); + } + + void postvisit( const VariableExpr * node ) { + readonlyInsert( &node->var ); + } + + void postvisit( const OffsetofExpr * node ) { + readonlyInsert( &node->member ); + } + + void postvisit( const DeletedExpr * node ) { + readonlyInsert( &node->deleteStmt ); + } + + void readonlyUpdates() { + for ( readonly * ptr : readonlyCache ) { + auto it = nodeCache.find( ptr->get() ); + if ( nodeCache.end() != it ) { + *ptr = it->second; + } + } + } +}; + +template +node_t * shallowCopy( const node_t * localRoot ) { + return localRoot->clone(); +} + +template +node_t * deepCopy( const node_t * localRoot ) { + Pass< DeepCopyCore > dc; + node_t const * newRoot = localRoot->accept( dc ); + dc.core.readonlyUpdates(); + return const_cast< node_t * >( newRoot ); +} + +} + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/AST/Decl.cpp =================================================================== --- src/AST/Decl.cpp (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/AST/Decl.cpp (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -50,5 +50,7 @@ const Type * FunctionDecl::get_type() const { return type.get(); } -void FunctionDecl::set_type(Type * t) { type = strict_dynamic_cast< FunctionType* >( t ); } +void FunctionDecl::set_type( const Type * t ) { + type = strict_dynamic_cast< const FunctionType * >( t ); +} // --- TypeDecl Index: src/AST/Decl.hpp =================================================================== --- src/AST/Decl.hpp (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/AST/Decl.hpp (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -33,5 +33,7 @@ // Must be included in *all* AST classes; should be #undef'd at the end of the file -#define MUTATE_FRIEND template friend node_t * mutate(const node_t * node); +#define MUTATE_FRIEND \ + template friend node_t * mutate(const node_t * node); \ + template friend node_t * shallowCopy(const node_t * node); namespace ast { @@ -88,5 +90,5 @@ virtual const Type * get_type() const = 0; /// Set type of this declaration. May be verified by subclass - virtual void set_type(Type *) = 0; + virtual void set_type( const Type * ) = 0; const DeclWithType * accept( Visitor & v ) const override = 0; @@ -111,5 +113,5 @@ const Type* get_type() const override { return type; } - void set_type( Type * ty ) override { type = ty; } + void set_type( const Type * ty ) override { type = ty; } const DeclWithType * accept( Visitor& v ) const override { return v.visit( this ); } @@ -133,5 +135,5 @@ const Type * get_type() const override; - void set_type(Type * t) override; + void set_type( const Type * t ) override; bool has_body() const { return stmts; } @@ -150,6 +152,7 @@ std::vector> assertions; - NamedTypeDecl( const CodeLocation& loc, const std::string& name, Storage::Classes storage, - Type* b, Linkage::Spec spec = Linkage::Cforall ) + NamedTypeDecl( + const CodeLocation & loc, const std::string & name, Storage::Classes storage, + const Type * b, Linkage::Spec spec = Linkage::Cforall ) : Decl( loc, name, storage, spec ), base( b ), params(), assertions() {} @@ -186,8 +189,9 @@ }; - TypeDecl( const CodeLocation & loc, const std::string & name, Storage::Classes storage, Type * b, - Kind k, bool s, Type * i = nullptr ) - : NamedTypeDecl( loc, name, storage, b ), kind( k ), sized( k == Ttype || s ), - init( i ) {} + TypeDecl( + const CodeLocation & loc, const std::string & name, Storage::Classes storage, + const Type * b, TypeDecl::Kind k, bool s, const Type * i = nullptr ) + : NamedTypeDecl( loc, name, storage, b ), kind( k ), sized( k == TypeDecl::Ttype || s ), + init( i ) {} const char * typeString() const override; Index: src/AST/Eval.hpp =================================================================== --- src/AST/Eval.hpp (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) +++ src/AST/Eval.hpp (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -0,0 +1,37 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// Eval.hpp -- +// +// Author : Aaron B. Moss +// Created On : Fri Jun 28 14:00:00 2019 +// Last Modified By : Aaron B. Moss +// Created On : Fri Jun 28 14:00:00 2019 +// Update Count : 1 +// + +#include +#include + +#include "Expr.hpp" + +namespace ast { + +/// Create a new UntypedExpr with the given arguments +template< typename... Args > +UntypedExpr * call( const CodeLocation & loc, const std::string & name, Args &&... args ) { + return new UntypedExpr { + loc, new NameExpr { loc, name }, + std::vector< ptr< Expr > > { std::forward< Args >( args )... } }; +} + +} + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/AST/Expr.cpp =================================================================== --- src/AST/Expr.cpp (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/AST/Expr.cpp (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -20,5 +20,8 @@ #include +#include "Copy.hpp" // for shallowCopy +#include "Eval.hpp" // for call #include "GenericSubstitution.hpp" +#include "LinkageSpec.hpp" #include "Stmt.hpp" #include "Type.hpp" @@ -27,9 +30,18 @@ #include "Common/SemanticError.h" #include "GenPoly/Lvalue.h" // for referencesPermissable -#include "InitTweak/InitTweak.h" // for getPointerBase +#include "InitTweak/InitTweak.h" // for getFunction, getPointerBase #include "ResolvExpr/typeops.h" // for extractResultType #include "Tuples/Tuples.h" // for makeTupleType namespace ast { + +namespace { + std::set const lvalueFunctionNames = {"*?", "?[?]"}; +} + +// --- Expr +bool Expr::get_lvalue() const { + return false; +} // --- ApplicationExpr @@ -46,4 +58,11 @@ } +bool ApplicationExpr::get_lvalue() const { + if ( const DeclWithType * func = InitTweak::getFunction( this ) ) { + return func->linkage == Linkage::Intrinsic && lvalueFunctionNames.count( func->name ); + } + return false; +} + // --- UntypedExpr @@ -51,7 +70,5 @@ assert( arg ); - UntypedExpr * ret = new UntypedExpr{ - loc, new NameExpr{loc, "*?"}, std::vector>{ ptr{ arg } } - }; + UntypedExpr * ret = call( loc, "*?", arg ); if ( const Type * ty = arg->result ) { const Type * base = InitTweak::getPointerBase( ty ); @@ -65,8 +82,12 @@ // base type ret->result = base; - add_qualifiers( ret->result, CV::Lvalue ); } } return ret; +} + +bool UntypedExpr::get_lvalue() const { + std::string fname = InitTweak::getFunctionName( this ); + return lvalueFunctionNames.count( fname ); } @@ -74,7 +95,5 @@ assert( lhs && rhs ); - UntypedExpr * ret = new UntypedExpr{ - loc, new NameExpr{loc, "?=?"}, std::vector>{ ptr{ lhs }, ptr{ rhs } } - }; + UntypedExpr * ret = call( loc, "?=?", lhs, rhs ); if ( lhs->result && rhs->result ) { // if both expressions are typed, assumes that this assignment is a C bitwise assignment, @@ -108,8 +127,7 @@ AddressExpr::AddressExpr( const CodeLocation & loc, const Expr * a ) : Expr( loc ), arg( a ) { if ( arg->result ) { - if ( arg->result->is_lvalue() ) { + if ( arg->get_lvalue() ) { // lvalue, retains all levels of reference, and gains a pointer inside the references Type * res = addrType( arg->result ); - res->set_lvalue( false ); // result of & is never an lvalue result = res; } else { @@ -118,5 +136,4 @@ dynamic_cast< const ReferenceType * >( arg->result.get() ) ) { Type * res = addrType( refType->base ); - res->set_lvalue( false ); // result of & is never an lvalue result = res; } else { @@ -139,8 +156,19 @@ : Expr( loc, new VoidType{} ), arg( a ), isGenerated( g ) {} +bool CastExpr::get_lvalue() const { + // This is actually wrong by C, but it works with our current set-up. + return arg->get_lvalue(); +} + // --- KeywordCastExpr const char * KeywordCastExpr::targetString() const { return AggregateDecl::aggrString( target ); +} + +// --- UntypedMemberExpr + +bool UntypedMemberExpr::get_lvalue() const { + return aggregate->get_lvalue(); } @@ -153,10 +181,59 @@ assert( aggregate->result ); - // take ownership of member type - result = mem->get_type(); + // Deep copy on result type avoids mutation on transitively multiply referenced object. + // + // Example, adapted from parts of builtins and bootloader: + // + // forall(dtype T) + // struct __Destructor { + // T * object; + // void (*dtor)(T *); + // }; + // + // forall(dtype S) + // void foo(__Destructor(S) &d) { + // if (d.dtor) { // here + // } + // } + // + // Let e be the "d.dtor" guard espression, which is MemberExpr after resolve. Let d be the + // declaration of member __Destructor.dtor (an ObjectDecl), as accessed via the top-level + // declaration of __Destructor. Consider the types e.result and d.type. In the old AST, one + // is a clone of the other. Ordinary new-AST use would set them up as a multiply-referenced + // object. + // + // e.result: PointerType + // .base: FunctionType + // .params.front(): ObjectDecl, the anonymous parameter of type T* + // .type: PointerType + // .base: TypeInstType + // let x = that + // let y = similar, except start from d.type + // + // Consider two code lines down, genericSubstitution(...).apply(result). + // + // Applying this chosen-candidate's type substitution means modifying x, substituting + // S for T. This mutation should affect x and not y. + + result = deepCopy(mem->get_type()); + // substitute aggregate generic parameters into member type genericSubstitution( aggregate->result ).apply( result ); - // ensure lvalue and appropriate restrictions from aggregate type - add_qualifiers( result, aggregate->result->qualifiers | CV::Lvalue ); + // ensure appropriate restrictions from aggregate type + add_qualifiers( result, aggregate->result->qualifiers ); +} + +MemberExpr::MemberExpr( const CodeLocation & loc, const DeclWithType * mem, const Expr * agg, + MemberExpr::NoOpConstruction overloadSelector ) +: Expr( loc ), member( mem ), aggregate( agg ) { + assert( member ); + assert( aggregate ); + assert( aggregate->result ); + (void) overloadSelector; +} + +bool MemberExpr::get_lvalue() const { + // This is actually wrong by C, but it works with our current set-up. + return true; } @@ -170,6 +247,10 @@ assert( var ); assert( var->get_type() ); - result = var->get_type(); - add_qualifiers( result, CV::Lvalue ); + result = shallowCopy( var->get_type() ); +} + +bool VariableExpr::get_lvalue() const { + // It isn't always an lvalue, but it is never an rvalue. + return true; } @@ -258,4 +339,11 @@ : Expr( loc, new BasicType{ BasicType::SignedInt } ), arg1( a1 ), arg2( a2 ), isAnd( ia ) {} +// --- CommaExpr +bool CommaExpr::get_lvalue() const { + // This is wrong by C, but the current implementation uses it. + // (ex: Specialize, Lvalue and Box) + return arg2->get_lvalue(); +} + // --- ConstructorExpr @@ -276,5 +364,8 @@ assert( t && i ); result = t; - add_qualifiers( result, CV::Lvalue ); +} + +bool CompoundLiteralExpr::get_lvalue() const { + return true; } @@ -293,5 +384,8 @@ // like MemberExpr, TupleIndexExpr is always an lvalue result = type->types[ index ]; - add_qualifiers( result, CV::Lvalue ); +} + +bool TupleIndexExpr::get_lvalue() const { + return tuple->get_lvalue(); } Index: src/AST/Expr.hpp =================================================================== --- src/AST/Expr.hpp (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/AST/Expr.hpp (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -31,5 +31,8 @@ // Must be included in *all* AST classes; should be #undef'd at the end of the file -#define MUTATE_FRIEND template friend node_t * mutate(const node_t * node); +#define MUTATE_FRIEND \ + template friend node_t * mutate(const node_t * node); \ + template friend node_t * shallowCopy(const node_t * node); + class ConverterOldToNew; @@ -42,5 +45,5 @@ struct ParamEntry { UniqueId decl; - ptr declptr; + readonly declptr; ptr actualType; ptr formalType; @@ -62,22 +65,33 @@ class Expr : public ParseNode { public: - /// Saves space (~16 bytes) by combining ResnSlots and InferredParams + /* + * NOTE: the union approach is incorrect until the case of + * partial resolution in InferMatcher is eliminated. + * it is reverted to allow unresolved and resolved parameters + * to coexist in an expression node. + */ struct InferUnion { + // mode is now unused enum { Empty, Slots, Params } mode; - union data_t { - char def; - ResnSlots resnSlots; - InferredParams inferParams; - - data_t() : def('\0') {} - ~data_t() {} + struct data_t { + // char def; + ResnSlots * resnSlots; + InferredParams * inferParams; + + data_t(): resnSlots(nullptr), inferParams(nullptr) {} + data_t(const data_t &other) = delete; + ~data_t() { + delete resnSlots; + delete inferParams; + } } data; /// initializes from other InferUnion void init_from( const InferUnion& o ) { - switch ( o.mode ) { - case Empty: return; - case Slots: new(&data.resnSlots) ResnSlots{ o.data.resnSlots }; return; - case Params: new(&data.inferParams) InferredParams{ o.data.inferParams }; return; + if (o.data.resnSlots) { + data.resnSlots = new ResnSlots(*o.data.resnSlots); + } + if (o.data.inferParams) { + data.inferParams = new InferredParams(*o.data.inferParams); } } @@ -85,19 +99,8 @@ /// initializes from other InferUnion (move semantics) void init_from( InferUnion&& o ) { - switch ( o.mode ) { - case Empty: return; - case Slots: new(&data.resnSlots) ResnSlots{ std::move(o.data.resnSlots) }; return; - case Params: - new(&data.inferParams) InferredParams{ std::move(o.data.inferParams) }; return; - } - } - - /// clears variant fields - void reset() { - switch( mode ) { - case Empty: return; - case Slots: data.resnSlots.~ResnSlots(); return; - case Params: data.inferParams.~InferredParams(); return; - } + data.resnSlots = o.data.resnSlots; + data.inferParams = o.data.inferParams; + o.data.resnSlots = nullptr; + o.data.inferParams = nullptr; } @@ -107,18 +110,17 @@ InferUnion& operator= ( const InferUnion& ) = delete; InferUnion& operator= ( InferUnion&& ) = delete; - ~InferUnion() { reset(); } + + bool hasSlots() const { return data.resnSlots; } ResnSlots& resnSlots() { - switch (mode) { - case Empty: new(&data.resnSlots) ResnSlots{}; mode = Slots; // fallthrough - case Slots: return data.resnSlots; - case Params: assertf(false, "Cannot return to resnSlots from Params"); abort(); + if (!data.resnSlots) { + data.resnSlots = new ResnSlots(); } - assertf(false, "unreachable"); + return *data.resnSlots; } const ResnSlots& resnSlots() const { - if (mode == Slots) { - return data.resnSlots; + if (data.resnSlots) { + return *data.resnSlots; } assertf(false, "Mode was not already resnSlots"); @@ -127,15 +129,13 @@ InferredParams& inferParams() { - switch (mode) { - case Slots: data.resnSlots.~ResnSlots(); // fallthrough - case Empty: new(&data.inferParams) InferredParams{}; mode = Params; // fallthrough - case Params: return data.inferParams; + if (!data.inferParams) { + data.inferParams = new InferredParams(); } - assertf(false, "unreachable"); + return *data.inferParams; } const InferredParams& inferParams() const { - if (mode == Params) { - return data.inferParams; + if (data.inferParams) { + return *data.inferParams; } assertf(false, "Mode was not already Params"); @@ -143,17 +143,9 @@ } - void set_inferParams( InferredParams && ps ) { - switch(mode) { - case Slots: - data.resnSlots.~ResnSlots(); - // fallthrough - case Empty: - new(&data.inferParams) InferredParams{ std::move( ps ) }; - mode = Params; - break; - case Params: - data.inferParams = std::move( ps ); - break; - } + void set_inferParams( InferredParams * ps ) { + delete data.resnSlots; + data.resnSlots = nullptr; + delete data.inferParams; + data.inferParams = ps; } @@ -161,16 +153,28 @@ /// and the other is in `Params`. void splice( InferUnion && o ) { - if ( o.mode == Empty ) return; - if ( mode == Empty ) { init_from( o ); return; } - assert( mode == o.mode && "attempt to splice incompatible InferUnion" ); - - if ( mode == Slots ){ - data.resnSlots.insert( - data.resnSlots.end(), o.data.resnSlots.begin(), o.data.resnSlots.end() ); - } else if ( mode == Params ) { - for ( const auto & p : o.data.inferParams ) { - data.inferParams[p.first] = std::move(p.second); + if (o.data.resnSlots) { + if (data.resnSlots) { + data.resnSlots->insert( + data.resnSlots->end(), o.data.resnSlots->begin(), o.data.resnSlots->end() ); + delete o.data.resnSlots; } - } else assertf(false, "invalid mode"); + else { + data.resnSlots = o.data.resnSlots; + } + o.data.resnSlots = nullptr; + } + + if (o.data.inferParams) { + if (data.inferParams) { + for ( const auto & p : *o.data.inferParams ) { + (*data.inferParams)[p.first] = std::move(p.second); + } + delete o.data.inferParams; + } + else { + data.inferParams = o.data.inferParams; + } + o.data.inferParams = nullptr; + } } }; @@ -185,4 +189,5 @@ Expr * set_extension( bool ex ) { extension = ex; return this; } + virtual bool get_lvalue() const; virtual const Expr * accept( Visitor & v ) const override = 0; @@ -201,4 +206,6 @@ ApplicationExpr( const CodeLocation & loc, const Expr * f, std::vector> && as = {} ); + bool get_lvalue() const final; + const Expr * accept( Visitor & v ) const override { return v.visit( this ); } private: @@ -215,4 +222,6 @@ UntypedExpr( const CodeLocation & loc, const Expr * f, std::vector> && as = {} ) : Expr( loc ), func( f ), args( std::move(as) ) {} + + bool get_lvalue() const final; /// Creates a new dereference expression @@ -291,4 +300,6 @@ CastExpr( const Expr * a ) : CastExpr( a->location, a, GeneratedCast ) {} + bool get_lvalue() const final; + const Expr * accept( Visitor & v ) const override { return v.visit( this ); } private: @@ -338,4 +349,6 @@ : Expr( loc ), member( mem ), aggregate( agg ) { assert( aggregate ); } + bool get_lvalue() const final; + const Expr * accept( Visitor & v ) const override { return v.visit( this ); } private: @@ -352,8 +365,17 @@ MemberExpr( const CodeLocation & loc, const DeclWithType * mem, const Expr * agg ); + bool get_lvalue() const final; + const Expr * accept( Visitor & v ) const override { return v.visit( this ); } private: MemberExpr * clone() const override { return new MemberExpr{ *this }; } MUTATE_FRIEND + + // Custructor overload meant only for AST conversion + enum NoOpConstruction { NoOpConstructionChosen }; + MemberExpr( const CodeLocation & loc, const DeclWithType * mem, const Expr * agg, + NoOpConstruction overloadSelector ); + friend class ::ConverterOldToNew; + friend class ::ConverterNewToOld; }; @@ -365,4 +387,6 @@ VariableExpr( const CodeLocation & loc ); VariableExpr( const CodeLocation & loc, const DeclWithType * v ); + + bool get_lvalue() const final; /// generates a function pointer for a given function @@ -532,5 +556,9 @@ CommaExpr( const CodeLocation & loc, const Expr * a1, const Expr * a2 ) - : Expr( loc ), arg1( a1 ), arg2( a2 ) {} + : Expr( loc ), arg1( a1 ), arg2( a2 ) { + this->result = a2->result; + } + + bool get_lvalue() const final; const Expr * accept( Visitor & v ) const override { return v.visit( this ); } @@ -605,4 +633,6 @@ CompoundLiteralExpr( const CodeLocation & loc, const Type * t, const Init * i ); + bool get_lvalue() const final; + const Expr * accept( Visitor & v ) const override { return v.visit( this ); } private: @@ -660,4 +690,6 @@ TupleIndexExpr( const CodeLocation & loc, const Expr * t, unsigned i ); + + bool get_lvalue() const final; const Expr * accept( Visitor & v ) const override { return v.visit( this ); } Index: src/AST/ForallSubstitutionTable.cpp =================================================================== --- src/AST/ForallSubstitutionTable.cpp (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) +++ src/AST/ForallSubstitutionTable.cpp (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -0,0 +1,54 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// ForallSubstitutionTable.cpp -- +// +// Author : Aaron B. Moss +// Created On : Thu Jun 27 14:00:00 2019 +// Last Modified By : Aaron B. Moss +// Last Modified On : Thu Jun 27 14:00:00 2019 +// Update Count : 1 +// + +#include "ForallSubstitutionTable.hpp" + +#include +#include + +#include "Copy.hpp" // for shallowCopy +#include "Decl.hpp" +#include "Node.hpp" +#include "Type.hpp" +#include "Visitor.hpp" + +namespace ast { + +std::vector< ptr< TypeDecl > > ForallSubstitutionTable::clone( + const std::vector< ptr< TypeDecl > > & forall, Visitor & v +) { + std::vector< ptr< TypeDecl > > new_forall; + new_forall.reserve( forall.size() ); + + for ( const ast::TypeDecl * d : forall ) { + // create cloned type decl and insert into substitution map before further mutation + auto new_d = shallowCopy( d ); + decls.insert( d, new_d ); + // perform other mutations and add to output + auto newer_d = v.visit( new_d ); + assert( new_d == newer_d && "Newly cloned TypeDecl must retain identity" ); + new_forall.emplace_back( new_d ); + } + + return new_forall; +} + +} + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/AST/ForallSubstitutionTable.hpp =================================================================== --- src/AST/ForallSubstitutionTable.hpp (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) +++ src/AST/ForallSubstitutionTable.hpp (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -0,0 +1,57 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// ForallSubstitutionTable.hpp -- +// +// Author : Aaron B. Moss +// Created On : Thu Jun 27 14:00:00 2019 +// Last Modified By : Aaron B. Moss +// Last Modified On : Thu Jun 27 14:00:00 2019 +// Update Count : 1 +// + +#pragma once + +#include + +#include "Node.hpp" // for ptr +#include "Common/ScopedMap.h" + +namespace ast { + +class TypeDecl; +class Visitor; + +/// Wrapper for TypeDecl substitution table +class ForallSubstitutionTable { + ScopedMap< const TypeDecl *, const TypeDecl * > decls; + +public: + /// Replaces given declaration with value in the table, if present, otherwise returns argument + const TypeDecl * replace( const TypeDecl * d ) { + auto it = decls.find( d ); + if ( it != decls.end() ) return it->second; + return d; + } + + /// Builds a new forall list mutated according to the given visitor + std::vector< ptr< TypeDecl > > clone( + const std::vector< ptr< TypeDecl > > & forall, Visitor & v ); + + /// Introduces a new lexical scope + void beginScope() { decls.beginScope(); } + + /// Concludes a lexical scope + void endScope() { decls.endScope(); } +}; + +} + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/AST/ForallSubstitutor.hpp =================================================================== --- src/AST/ForallSubstitutor.hpp (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) +++ src/AST/ForallSubstitutor.hpp (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -0,0 +1,58 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// ForallSubstitutor.hpp -- +// +// Author : Aaron B. Moss +// Created On : Wed Jun 26 15:00:00 2019 +// Last Modified By : Aaron B. Moss +// Last Modified On : Wed Jun 26 15:00:00 2019 +// Update Count : 1 +// + +#include "Pass.hpp" + +namespace ast { + +class Expr; + +/// Visitor that correctly substitutes TypeDecl while maintaining TypeInstType bindings. +/// Also has some convenience methods to mutate fields. +struct ForallSubstitutor : public WithForallSubstitutor, public WithVisitorRef { + /// Substitute TypeInstType base type + readonly< TypeDecl > operator() ( const readonly< TypeDecl > & o ) { + return subs.replace( o ); + } + + /// Make new forall-list clone + ParameterizedType::ForallList operator() ( const ParameterizedType::ForallList & o ) { + return subs.clone( o, *visitor ); + } + + /// Substitute parameter/return type + std::vector< ptr< DeclWithType > > operator() ( const std::vector< ptr< DeclWithType > > & o ) { + std::vector< ptr< DeclWithType > > n; + n.reserve( o.size() ); + for ( const DeclWithType * d : o ) { n.emplace_back( d->accept( *visitor ) ); } + return n; + } + + /// Substitute type parameter list + std::vector< ptr< Expr > > operator() ( const std::vector< ptr< Expr > > & o ) { + std::vector< ptr< Expr > > n; + n.reserve( o.size() ); + for ( const Expr * d : o ) { n.emplace_back( d->accept( *visitor ) ); } + return n; + } +}; + +} // namespace ast + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/AST/Fwd.hpp =================================================================== --- src/AST/Fwd.hpp (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/AST/Fwd.hpp (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -10,6 +10,6 @@ // Created On : Wed May 8 16:05:00 2019 // Last Modified By : Andrew Beach -// Last Modified On : Mon Jun 24 09:48:00 2019 -// Update Count : 1 +// Last Modified On : Thr Jul 23 14:15:00 2020 +// Update Count : 2 // @@ -108,7 +108,8 @@ class FunctionType; class ReferenceToType; -class StructInstType; -class UnionInstType; -class EnumInstType; +template class SueInstType; +using StructInstType = SueInstType; +using UnionInstType = SueInstType; +using EnumInstType = SueInstType; class TraitInstType; class TypeInstType; Index: src/AST/GenericSubstitution.cpp =================================================================== --- src/AST/GenericSubstitution.cpp (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/AST/GenericSubstitution.cpp (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -62,5 +62,5 @@ Pass builder; maybe_accept( ty, builder ); - return std::move(builder.pass.sub); + return std::move(builder.core.sub); } Index: src/AST/Init.hpp =================================================================== --- src/AST/Init.hpp (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/AST/Init.hpp (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -25,5 +25,7 @@ // Must be included in *all* AST classes; should be #undef'd at the end of the file -#define MUTATE_FRIEND template friend node_t * mutate(const node_t * node); +#define MUTATE_FRIEND \ + template friend node_t * mutate(const node_t * node); \ + template friend node_t * shallowCopy(const node_t * node); namespace ast { Index: src/AST/Node.cpp =================================================================== --- src/AST/Node.cpp (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/AST/Node.cpp (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -9,7 +9,7 @@ // Author : Thierry Delisle // Created On : Thu May 16 14:16:00 2019 -// Last Modified By : -// Last Modified On : -// Update Count : +// Last Modified By : Andrew Beach +// Last Modified On : Fri Jun 5 10:21:00 2020 +// Update Count : 1 // @@ -17,4 +17,5 @@ #include "Fwd.hpp" +#include // MEMORY DEBUG -- for raise #include @@ -29,12 +30,51 @@ #include "Print.hpp" -template< typename node_t, enum ast::Node::ref_type ref_t > -void ast::ptr_base::_inc( const node_t * node ) { node->increment(ref_t); } - -template< typename node_t, enum ast::Node::ref_type ref_t > -void ast::ptr_base::_dec( const node_t * node ) { node->decrement(ref_t); } - -template< typename node_t, enum ast::Node::ref_type ref_t > -void ast::ptr_base::_check() const { if(node) assert(node->was_ever_strong == false || node->strong_count > 0); } +/// MEMORY DEBUG -- allows breaking on ref-count changes of dynamically chosen object. +/// Process to use in GDB: +/// break ast::Node::_trap() +/// run +/// set variable MEM_TRAP_OBJ = +/// disable +/// continue +void * MEM_TRAP_OBJ = nullptr; + +void _trap( const void * node ) { + if ( node == MEM_TRAP_OBJ ) std::raise(SIGTRAP); +} + +[[noreturn]] static inline void strict_fail(const ast::Node * node) { + assertf(node, "strict_as had nullptr input."); + const ast::ParseNode * parse = dynamic_cast( node ); + if ( nullptr == parse ) { + assertf(nullptr, "%s (no location)", toString(node).c_str()); + } else if ( parse->location.isUnset() ) { + assertf(nullptr, "%s (unset location)", toString(node).c_str()); + } else { + assertf(nullptr, "%s (at %s:%d)", toString(node).c_str(), + parse->location.filename.c_str(), parse->location.first_line); + } +} + +template< typename node_t, enum ast::Node::ref_type ref_t > +void ast::ptr_base::_strict_fail() const { + strict_fail(node); +} + +template< typename node_t, enum ast::Node::ref_type ref_t > +void ast::ptr_base::_inc( const node_t * node ) { + node->increment(ref_t); + _trap( node ); +} + +template< typename node_t, enum ast::Node::ref_type ref_t > +void ast::ptr_base::_dec( const node_t * node, bool do_delete ) { + _trap( node ); + node->decrement( ref_t, do_delete ); +} + +template< typename node_t, enum ast::Node::ref_type ref_t > +void ast::ptr_base::_check() const { + // if(node) assert(node->was_ever_strong == false || node->strong_count > 0); +} template< typename node_t, enum ast::Node::ref_type ref_t > Index: src/AST/Node.hpp =================================================================== --- src/AST/Node.hpp (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/AST/Node.hpp (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -10,6 +10,6 @@ // Created On : Wed May 8 10:27:04 2019 // Last Modified By : Andrew Beach -// Last Modified On : Mon Jun 3 13:26:00 2019 -// Update Count : 5 +// Last Modified On : Fri Jun 5 9:47:00 2020 +// Update Count : 6 // @@ -38,5 +38,5 @@ Node& operator= (const Node&) = delete; Node& operator= (Node&&) = delete; - virtual ~Node() = default; + virtual ~Node() {} virtual const Node * accept( Visitor & v ) const = 0; @@ -57,4 +57,6 @@ template friend node_t * mutate(const node_t * node); + template + friend node_t * shallowCopy(const node_t * node); mutable size_t strong_count = 0; @@ -69,5 +71,5 @@ } - void decrement(ast::Node::ref_type ref) const { + void decrement(ast::Node::ref_type ref, bool do_delete = true) const { switch (ref) { case ref_type::strong: strong_count--; break; @@ -75,5 +77,5 @@ } - if(!strong_count && !weak_count) { + if( do_delete && !strong_count && !weak_count) { delete this; } @@ -94,5 +96,5 @@ assertf( node->weak_count == 0, - "Error: mutating node with weak references to it will invalided some references" + "Error: mutating node with weak references to it will invalidate some references" ); return node->clone(); @@ -104,5 +106,5 @@ // skip mutate if equivalent if ( node->*field == val ) return node; - + // mutate and return node_t * ret = mutate( node ); @@ -123,4 +125,13 @@ (ret->*field)[i] = std::forward< field_t >( val ); return ret; +} + +/// Mutate an entire indexed collection by cloning to accepted value +template +const node_t * mutate_each( const node_t * node, coll_t parent_t::* field, Visitor & v ) { + for ( unsigned i = 0; i < (node->*field).size(); ++i ) { + node = mutate_field_index( node, field, i, (node->*field)[i]->accept( v ) ); + } + return node; } @@ -219,11 +230,27 @@ operator const node_t * () const { _check(); return node; } + const node_t * release() { + const node_t * ret = node; + if ( node ) { + _dec(node, false); + node = nullptr; + } + return ret; + } + /// wrapper for convenient access to dynamic_cast template const o_node_t * as() const { _check(); return dynamic_cast(node); } - /// wrapper for convenient access to strict_dynamic_cast + /// Wrapper that makes sure dynamic_cast returns non-null. template - const o_node_t * strict_as() const { _check(); return strict_dynamic_cast(node); } + const o_node_t * strict_as() const { + if (const o_node_t * ret = as()) return ret; + _strict_fail(); + } + + /// Wrapper that makes sure dynamic_cast does not fail. + template + const o_node_t * strict_as() const { return node ? strict_as() : nullptr; } /// Returns a mutable version of the pointer in this node. @@ -244,6 +271,7 @@ void _inc( const node_t * other ); - void _dec( const node_t * other ); + void _dec( const node_t * other, bool do_delete = true ); void _check() const; + void _strict_fail() const __attribute__((noreturn)); const node_t * node; Index: src/AST/Pass.hpp =================================================================== --- src/AST/Pass.hpp (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/AST/Pass.hpp (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -8,5 +8,5 @@ // // Author : Thierry Delisle -// Created On : Thu May 09 15::37::05 2019 +// Created On : Thu May 09 15:37:05 2019 // Last Modified By : // Last Modified On : @@ -35,4 +35,6 @@ #include "AST/SymbolTable.hpp" +#include "AST/ForallSubstitutionTable.hpp" + // Private prelude header, needed for some of the magic tricks this class pulls off #include "AST/Pass.proto.hpp" @@ -46,35 +48,38 @@ // // Several additional features are available through inheritance -// | WithTypeSubstitution - provides polymorphic const TypeSubstitution * env for the -// current expression -// | WithStmtsToAdd - provides the ability to insert statements before or after the current -// statement by adding new statements into stmtsToAddBefore or -// stmtsToAddAfter respectively. -// | WithDeclsToAdd - provides the ability to insert declarations before or after the current -// declarations by adding new DeclStmt into declsToAddBefore or -// declsToAddAfter respectively. -// | WithShortCircuiting - provides the ability to skip visiting child nodes; set visit_children -// to false in pre{visit,visit} to skip visiting children -// | WithGuards - provides the ability to save/restore data like a LIFO stack; to save, -// call GuardValue with the variable to save, the variable will -// automatically be restored to its previous value after the corresponding -// postvisit/postmutate teminates. -// | WithVisitorRef - provides an pointer to the templated visitor wrapper -// | WithSymbolTable - provides symbol table functionality +// | WithTypeSubstitution - provides polymorphic const TypeSubstitution * env for the +// current expression +// | WithStmtsToAdd - provides the ability to insert statements before or after the current +// statement by adding new statements into stmtsToAddBefore or +// stmtsToAddAfter respectively. +// | WithDeclsToAdd - provides the ability to insert declarations before or after the +// current declarations by adding new DeclStmt into declsToAddBefore or +// declsToAddAfter respectively. +// | WithShortCircuiting - provides the ability to skip visiting child nodes; set visit_children +// to false in pre{visit,visit} to skip visiting children +// | WithGuards - provides the ability to save/restore data like a LIFO stack; to save, +// call GuardValue with the variable to save, the variable will +// automatically be restored to its previous value after the +// corresponding postvisit/postmutate teminates. +// | WithVisitorRef - provides an pointer to the templated visitor wrapper +// | WithSymbolTable - provides symbol table functionality +// | WithForallSubstitutor - maintains links between TypeInstType and TypeDecl under mutation //------------------------------------------------------------------------------------------------- -template< typename pass_t > +template< typename core_t > class Pass final : public ast::Visitor { public: + using core_type = core_t; + using type = Pass; + /// Forward any arguments to the pass constructor /// Propagate 'this' if necessary template< typename... Args > Pass( Args &&... args) - : pass( std::forward( args )... ) + : core( std::forward( args )... ) { // After the pass is constructed, check if it wants the have a pointer to the wrapping visitor - typedef Pass this_t; - this_t * const * visitor = __pass::visitor(pass, 0); + type * const * visitor = __pass::visitor(core, 0); if(visitor) { - *const_cast( visitor ) = this; + *const_cast( visitor ) = this; } } @@ -82,6 +87,19 @@ virtual ~Pass() = default; + /// Construct and run a pass on a translation unit. + template< typename... Args > + static void run( std::list< ptr > & decls, Args &&... args ) { + Pass visitor( std::forward( args )... ); + accept_all( decls, visitor ); + } + + template< typename... Args > + static void run( std::list< ptr > & decls ) { + Pass visitor; + accept_all( decls, visitor ); + } + /// Storage for the actual pass - pass_t pass; + core_t core; /// Visit function declarations @@ -179,9 +197,9 @@ const ast::TypeSubstitution * visit( const ast::TypeSubstitution * ) override final; - template - friend void accept_all( std::list< ptr > & decls, Pass& visitor ); + template + friend void accept_all( std::list< ptr > & decls, Pass& visitor ); private: - bool __visit_children() { __pass::bool_ref * ptr = __pass::visit_children(pass, 0); return ptr ? *ptr : true; } + bool __visit_children() { __pass::bool_ref * ptr = __pass::visit_children(core, 0); return ptr ? *ptr : true; } private: @@ -202,4 +220,8 @@ container_t< ptr > call_accept( const container_t< ptr > & container ); + /// Mutate forall-list, accounting for presence of type substitution map + template + void mutate_forall( const node_t *& ); + public: /// Logic to call the accept and mutate the parent if needed, delegates call to accept @@ -210,14 +232,23 @@ /// Internal RAII guard for symbol table features struct guard_symtab { - guard_symtab( Pass & pass ): pass( pass ) { __pass::symtab::enter(pass, 0); } - ~guard_symtab() { __pass::symtab::leave(pass, 0); } - Pass & pass; + guard_symtab( Pass & pass ): pass( pass ) { __pass::symtab::enter(pass.core, 0); } + ~guard_symtab() { __pass::symtab::leave(pass.core, 0); } + Pass & pass; }; /// Internal RAII guard for scope features struct guard_scope { - guard_scope( Pass & pass ): pass( pass ) { __pass::scope::enter(pass, 0); } - ~guard_scope() { __pass::scope::leave(pass, 0); } - Pass & pass; + guard_scope( Pass & pass ): pass( pass ) { __pass::scope::enter(pass.core, 0); } + ~guard_scope() { __pass::scope::leave(pass.core, 0); } + Pass & pass; + }; + + /// Internal RAII guard for forall substitutions + struct guard_forall_subs { + guard_forall_subs( Pass & pass, const ParameterizedType * type ) + : pass( pass ), type( type ) { __pass::forall::enter(pass.core, 0, type ); } + ~guard_forall_subs() { __pass::forall::leave(pass.core, 0, type ); } + Pass & pass; + const ParameterizedType * type; }; @@ -227,6 +258,6 @@ /// Apply a pass to an entire translation unit -template -void accept_all( std::list< ast::ptr > &, ast::Pass & visitor ); +template +void accept_all( std::list< ast::ptr > &, ast::Pass & visitor ); //------------------------------------------------------------------------------------------------- @@ -268,6 +299,6 @@ }; - template< typename pass_t> - friend auto __pass::at_cleanup( pass_t & pass, int ) -> decltype( &pass.at_cleanup ); + template< typename core_t> + friend auto __pass::at_cleanup( core_t & core, int ) -> decltype( &core.at_cleanup ); public: @@ -305,7 +336,7 @@ /// Used to get a pointer to the pass with its wrapped type -template +template struct WithVisitorRef { - Pass * const visitor = nullptr; + Pass * const visitor = nullptr; }; @@ -314,4 +345,10 @@ SymbolTable symtab; }; + +/// Use when the templated visitor needs to keep TypeInstType instances properly linked to TypeDecl +struct WithForallSubstitutor { + ForallSubstitutionTable subs; +}; + } @@ -321,6 +358,6 @@ extern struct PassVisitorStats { size_t depth = 0; - Stats::Counters::MaxCounter * max = nullptr; - Stats::Counters::AverageCounter * avg = nullptr; + Stats::Counters::MaxCounter * max; + Stats::Counters::AverageCounter * avg; } pass_visitor_stats; } Index: src/AST/Pass.impl.hpp =================================================================== --- src/AST/Pass.impl.hpp (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/AST/Pass.impl.hpp (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -25,9 +25,11 @@ using namespace ast; \ /* back-up the visit children */ \ - __attribute__((unused)) ast::__pass::visit_children_guard guard1( ast::__pass::visit_children(pass, 0) ); \ + __attribute__((unused)) ast::__pass::visit_children_guard guard1( ast::__pass::visit_children(core, 0) ); \ /* setup the scope for passes that want to run code at exit */ \ - __attribute__((unused)) ast::__pass::guard_value guard2( ast::__pass::at_cleanup (pass, 0) ); \ + __attribute__((unused)) ast::__pass::guard_value guard2( ast::__pass::at_cleanup (core, 0) ); \ + /* begin tracing memory allocation if requested by this pass */ \ + __pass::beginTrace( core, 0 ); \ /* call the implementation of the previsit of this pass */ \ - __pass::previsit( pass, node, 0 ); + __pass::previsit( core, node, 0 ); #define VISIT( code... ) \ @@ -40,6 +42,8 @@ #define VISIT_END( type, node ) \ /* call the implementation of the postvisit of this pass */ \ - auto __return = __pass::postvisit( pass, node, 0 ); \ + auto __return = __pass::postvisit( core, node, 0 ); \ assertf(__return, "post visit should never return null"); \ + /* end tracing memory allocation if requested by this pass */ \ + __pass::endTrace( core, 0 ); \ return __return; @@ -119,7 +123,7 @@ } - template< typename pass_t > + template< typename core_t > template< typename node_t > - auto ast::Pass< pass_t >::call_accept( const node_t * node ) + auto ast::Pass< core_t >::call_accept( const node_t * node ) -> typename std::enable_if< !std::is_base_of::value && @@ -127,8 +131,7 @@ , decltype( node->accept(*this) ) >::type - { __pedantic_pass_assert( __visit_children() ); - __pedantic_pass_assert( expr ); + __pedantic_pass_assert( node ); static_assert( !std::is_base_of::value, "ERROR"); @@ -138,10 +141,10 @@ } - template< typename pass_t > - const ast::Expr * ast::Pass< pass_t >::call_accept( const ast::Expr * expr ) { + template< typename core_t > + const ast::Expr * ast::Pass< core_t >::call_accept( const ast::Expr * expr ) { __pedantic_pass_assert( __visit_children() ); __pedantic_pass_assert( expr ); - const ast::TypeSubstitution ** env_ptr = __pass::env( pass, 0); + const ast::TypeSubstitution ** env_ptr = __pass::env( core, 0); if ( env_ptr && expr->env ) { *env_ptr = expr->env; @@ -151,6 +154,6 @@ } - template< typename pass_t > - const ast::Stmt * ast::Pass< pass_t >::call_accept( const ast::Stmt * stmt ) { + template< typename core_t > + const ast::Stmt * ast::Pass< core_t >::call_accept( const ast::Stmt * stmt ) { __pedantic_pass_assert( __visit_children() ); __pedantic_pass_assert( stmt ); @@ -160,11 +163,11 @@ // get the stmts/decls that will need to be spliced in - auto stmts_before = __pass::stmtsToAddBefore( pass, 0); - auto stmts_after = __pass::stmtsToAddAfter ( pass, 0); - auto decls_before = __pass::declsToAddBefore( pass, 0); - auto decls_after = __pass::declsToAddAfter ( pass, 0); + auto stmts_before = __pass::stmtsToAddBefore( core, 0); + auto stmts_after = __pass::stmtsToAddAfter ( core, 0); + auto decls_before = __pass::declsToAddBefore( core, 0); + auto decls_after = __pass::declsToAddAfter ( core, 0); // These may be modified by subnode but most be restored once we exit this statemnet. - ValueGuardPtr< const ast::TypeSubstitution * > __old_env ( __pass::env( pass, 0) ); + ValueGuardPtr< const ast::TypeSubstitution * > __old_env ( __pass::env( core, 0) ); ValueGuardPtr< typename std::remove_pointer< decltype(stmts_before) >::type > __old_decls_before( stmts_before ); ValueGuardPtr< typename std::remove_pointer< decltype(stmts_after ) >::type > __old_decls_after ( stmts_after ); @@ -202,7 +205,7 @@ } - template< typename pass_t > + template< typename core_t > template< template class container_t > - container_t< ptr > ast::Pass< pass_t >::call_accept( const container_t< ptr > & statements ) { + container_t< ptr > ast::Pass< core_t >::call_accept( const container_t< ptr > & statements ) { __pedantic_pass_assert( __visit_children() ); if( statements.empty() ) return {}; @@ -215,8 +218,8 @@ // get the stmts/decls that will need to be spliced in - auto stmts_before = __pass::stmtsToAddBefore( pass, 0); - auto stmts_after = __pass::stmtsToAddAfter ( pass, 0); - auto decls_before = __pass::declsToAddBefore( pass, 0); - auto decls_after = __pass::declsToAddAfter ( pass, 0); + auto stmts_before = __pass::stmtsToAddBefore( core, 0); + auto stmts_after = __pass::stmtsToAddAfter ( core, 0); + auto decls_before = __pass::declsToAddBefore( core, 0); + auto decls_after = __pass::declsToAddAfter ( core, 0); // These may be modified by subnode but most be restored once we exit this statemnet. @@ -268,7 +271,7 @@ } - template< typename pass_t > + template< typename core_t > template< template class container_t, typename node_t > - container_t< ast::ptr > ast::Pass< pass_t >::call_accept( const container_t< ast::ptr > & container ) { + container_t< ast::ptr > ast::Pass< core_t >::call_accept( const container_t< ast::ptr > & container ) { __pedantic_pass_assert( __visit_children() ); if( container.empty() ) return {}; @@ -299,7 +302,7 @@ } - template< typename pass_t > + template< typename core_t > template - void ast::Pass< pass_t >::maybe_accept( + void ast::Pass< core_t >::maybe_accept( const node_t * & parent, child_t parent_t::*child @@ -323,4 +326,20 @@ } + + template< typename core_t > + template< typename node_t > + void ast::Pass< core_t >::mutate_forall( const node_t *& node ) { + if ( auto subs = __pass::forall::subs( core, 0 ) ) { + // tracking TypeDecl substitution, full clone + if ( node->forall.empty() ) return; + + node_t * mut = mutate( node ); + mut->forall = subs->clone( node->forall, *this ); + node = mut; + } else { + // not tracking TypeDecl substitution, just mutate + maybe_accept( node, &node_t::forall ); + } + } } @@ -333,6 +352,6 @@ //------------------------------------------------------------------------------------------------------------------------------------------------------------------------ -template< typename pass_t > -inline void ast::accept_all( std::list< ast::ptr > & decls, ast::Pass< pass_t > & visitor ) { +template< typename core_t > +inline void ast::accept_all( std::list< ast::ptr > & decls, ast::Pass< core_t > & visitor ) { // We are going to aggregate errors for all these statements SemanticErrorException errors; @@ -342,6 +361,6 @@ // get the stmts/decls that will need to be spliced in - auto decls_before = __pass::declsToAddBefore( visitor.pass, 0); - auto decls_after = __pass::declsToAddAfter ( visitor.pass, 0); + auto decls_before = __pass::declsToAddBefore( visitor.core, 0); + auto decls_after = __pass::declsToAddAfter ( visitor.core, 0); // update pass statitistics @@ -392,6 +411,6 @@ //-------------------------------------------------------------------------- // ObjectDecl -template< typename pass_t > -const ast::DeclWithType * ast::Pass< pass_t >::visit( const ast::ObjectDecl * node ) { +template< typename core_t > +const ast::DeclWithType * ast::Pass< core_t >::visit( const ast::ObjectDecl * node ) { VISIT_START( node ); @@ -406,5 +425,5 @@ ) - __pass::symtab::addId( pass, 0, node ); + __pass::symtab::addId( core, 0, node ); VISIT_END( DeclWithType, node ); @@ -413,9 +432,9 @@ //-------------------------------------------------------------------------- // FunctionDecl -template< typename pass_t > -const ast::DeclWithType * ast::Pass< pass_t >::visit( const ast::FunctionDecl * node ) { - VISIT_START( node ); - - __pass::symtab::addId( pass, 0, node ); +template< typename core_t > +const ast::DeclWithType * ast::Pass< core_t >::visit( const ast::FunctionDecl * node ) { + VISIT_START( node ); + + __pass::symtab::addId( core, 0, node ); VISIT(maybe_accept( node, &FunctionDecl::withExprs );) @@ -425,16 +444,16 @@ // shadow with exprs and not the other way around. guard_symtab guard { *this }; - __pass::symtab::addWith( pass, 0, node->withExprs, node ); + __pass::symtab::addWith( core, 0, node->withExprs, node ); { guard_symtab guard { *this }; // implicit add __func__ identifier as specified in the C manual 6.4.2.2 - static ast::ObjectDecl func( - node->location, "__func__", - new ast::ArrayType( - new ast::BasicType( ast::BasicType::Char, ast::CV::Qualifiers( ast::CV::Const ) ), + static ast::ptr< ast::ObjectDecl > func{ new ast::ObjectDecl{ + CodeLocation{}, "__func__", + new ast::ArrayType{ + new ast::BasicType{ ast::BasicType::Char, ast::CV::Const }, nullptr, VariableLen, DynamicDim - ) - ); - __pass::symtab::addId( pass, 0, &func ); + } + } }; + __pass::symtab::addId( core, 0, func ); VISIT( maybe_accept( node, &FunctionDecl::type ); @@ -454,11 +473,11 @@ //-------------------------------------------------------------------------- // StructDecl -template< typename pass_t > -const ast::Decl * ast::Pass< pass_t >::visit( const ast::StructDecl * node ) { +template< typename core_t > +const ast::Decl * ast::Pass< core_t >::visit( const ast::StructDecl * node ) { VISIT_START( node ); // make up a forward declaration and add it before processing the members // needs to be on the heap because addStruct saves the pointer - __pass::symtab::addStructFwd( pass, 0, node ); + __pass::symtab::addStructFwd( core, 0, node ); VISIT({ @@ -469,5 +488,5 @@ // this addition replaces the forward declaration - __pass::symtab::addStruct( pass, 0, node ); + __pass::symtab::addStruct( core, 0, node ); VISIT_END( Decl, node ); @@ -476,10 +495,10 @@ //-------------------------------------------------------------------------- // UnionDecl -template< typename pass_t > -const ast::Decl * ast::Pass< pass_t >::visit( const ast::UnionDecl * node ) { +template< typename core_t > +const ast::Decl * ast::Pass< core_t >::visit( const ast::UnionDecl * node ) { VISIT_START( node ); // make up a forward declaration and add it before processing the members - __pass::symtab::addUnionFwd( pass, 0, node ); + __pass::symtab::addUnionFwd( core, 0, node ); VISIT({ @@ -489,5 +508,5 @@ }) - __pass::symtab::addUnion( pass, 0, node ); + __pass::symtab::addUnion( core, 0, node ); VISIT_END( Decl, node ); @@ -496,9 +515,9 @@ //-------------------------------------------------------------------------- // EnumDecl -template< typename pass_t > -const ast::Decl * ast::Pass< pass_t >::visit( const ast::EnumDecl * node ) { - VISIT_START( node ); - - __pass::symtab::addEnum( pass, 0, node ); +template< typename core_t > +const ast::Decl * ast::Pass< core_t >::visit( const ast::EnumDecl * node ) { + VISIT_START( node ); + + __pass::symtab::addEnum( core, 0, node ); VISIT( @@ -513,6 +532,6 @@ //-------------------------------------------------------------------------- // TraitDecl -template< typename pass_t > -const ast::Decl * ast::Pass< pass_t >::visit( const ast::TraitDecl * node ) { +template< typename core_t > +const ast::Decl * ast::Pass< core_t >::visit( const ast::TraitDecl * node ) { VISIT_START( node ); @@ -523,5 +542,5 @@ }) - __pass::symtab::addTrait( pass, 0, node ); + __pass::symtab::addTrait( core, 0, node ); VISIT_END( Decl, node ); @@ -530,6 +549,6 @@ //-------------------------------------------------------------------------- // TypeDecl -template< typename pass_t > -const ast::Decl * ast::Pass< pass_t >::visit( const ast::TypeDecl * node ) { +template< typename core_t > +const ast::Decl * ast::Pass< core_t >::visit( const ast::TypeDecl * node ) { VISIT_START( node ); @@ -543,5 +562,5 @@ // note that assertions come after the type is added to the symtab, since they are not part of the type proper // and may depend on the type itself - __pass::symtab::addType( pass, 0, node ); + __pass::symtab::addType( core, 0, node ); VISIT( @@ -559,6 +578,6 @@ //-------------------------------------------------------------------------- // TypedefDecl -template< typename pass_t > -const ast::Decl * ast::Pass< pass_t >::visit( const ast::TypedefDecl * node ) { +template< typename core_t > +const ast::Decl * ast::Pass< core_t >::visit( const ast::TypedefDecl * node ) { VISIT_START( node ); @@ -569,5 +588,5 @@ }) - __pass::symtab::addType( pass, 0, node ); + __pass::symtab::addType( core, 0, node ); VISIT( maybe_accept( node, &TypedefDecl::assertions ); ) @@ -578,6 +597,6 @@ //-------------------------------------------------------------------------- // AsmDecl -template< typename pass_t > -const ast::AsmDecl * ast::Pass< pass_t >::visit( const ast::AsmDecl * node ) { +template< typename core_t > +const ast::AsmDecl * ast::Pass< core_t >::visit( const ast::AsmDecl * node ) { VISIT_START( node ); @@ -591,6 +610,6 @@ //-------------------------------------------------------------------------- // StaticAssertDecl -template< typename pass_t > -const ast::StaticAssertDecl * ast::Pass< pass_t >::visit( const ast::StaticAssertDecl * node ) { +template< typename core_t > +const ast::StaticAssertDecl * ast::Pass< core_t >::visit( const ast::StaticAssertDecl * node ) { VISIT_START( node ); @@ -605,13 +624,13 @@ //-------------------------------------------------------------------------- // CompoundStmt -template< typename pass_t > -const ast::CompoundStmt * ast::Pass< pass_t >::visit( const ast::CompoundStmt * node ) { +template< typename core_t > +const ast::CompoundStmt * ast::Pass< core_t >::visit( const ast::CompoundStmt * node ) { VISIT_START( node ); VISIT({ // do not enter a new scope if inFunction is true - needs to check old state before the assignment - auto guard1 = makeFuncGuard( [this, inFunction = this->inFunction]() { - if ( ! inFunction ) __pass::symtab::enter(pass, 0); - }, [this, inFunction = this->inFunction]() { - if ( ! inFunction ) __pass::symtab::leave(pass, 0); + auto guard1 = makeFuncGuard( [this, inFunctionCpy = this->inFunction]() { + if ( ! inFunctionCpy ) __pass::symtab::enter(core, 0); + }, [this, inFunctionCpy = this->inFunction]() { + if ( ! inFunctionCpy ) __pass::symtab::leave(core, 0); }); ValueGuard< bool > guard2( inFunction ); @@ -625,6 +644,6 @@ //-------------------------------------------------------------------------- // ExprStmt -template< typename pass_t > -const ast::Stmt * ast::Pass< pass_t >::visit( const ast::ExprStmt * node ) { +template< typename core_t > +const ast::Stmt * ast::Pass< core_t >::visit( const ast::ExprStmt * node ) { VISIT_START( node ); @@ -638,6 +657,6 @@ //-------------------------------------------------------------------------- // AsmStmt -template< typename pass_t > -const ast::Stmt * ast::Pass< pass_t >::visit( const ast::AsmStmt * node ) { +template< typename core_t > +const ast::Stmt * ast::Pass< core_t >::visit( const ast::AsmStmt * node ) { VISIT_START( node ) @@ -654,6 +673,6 @@ //-------------------------------------------------------------------------- // DirectiveStmt -template< typename pass_t > -const ast::Stmt * ast::Pass< pass_t >::visit( const ast::DirectiveStmt * node ) { +template< typename core_t > +const ast::Stmt * ast::Pass< core_t >::visit( const ast::DirectiveStmt * node ) { VISIT_START( node ) @@ -663,6 +682,6 @@ //-------------------------------------------------------------------------- // IfStmt -template< typename pass_t > -const ast::Stmt * ast::Pass< pass_t >::visit( const ast::IfStmt * node ) { +template< typename core_t > +const ast::Stmt * ast::Pass< core_t >::visit( const ast::IfStmt * node ) { VISIT_START( node ); @@ -681,6 +700,6 @@ //-------------------------------------------------------------------------- // WhileStmt -template< typename pass_t > -const ast::Stmt * ast::Pass< pass_t >::visit( const ast::WhileStmt * node ) { +template< typename core_t > +const ast::Stmt * ast::Pass< core_t >::visit( const ast::WhileStmt * node ) { VISIT_START( node ); @@ -698,6 +717,6 @@ //-------------------------------------------------------------------------- // ForStmt -template< typename pass_t > -const ast::Stmt * ast::Pass< pass_t >::visit( const ast::ForStmt * node ) { +template< typename core_t > +const ast::Stmt * ast::Pass< core_t >::visit( const ast::ForStmt * node ) { VISIT_START( node ); @@ -716,6 +735,6 @@ //-------------------------------------------------------------------------- // SwitchStmt -template< typename pass_t > -const ast::Stmt * ast::Pass< pass_t >::visit( const ast::SwitchStmt * node ) { +template< typename core_t > +const ast::Stmt * ast::Pass< core_t >::visit( const ast::SwitchStmt * node ) { VISIT_START( node ); @@ -730,6 +749,6 @@ //-------------------------------------------------------------------------- // CaseStmt -template< typename pass_t > -const ast::Stmt * ast::Pass< pass_t >::visit( const ast::CaseStmt * node ) { +template< typename core_t > +const ast::Stmt * ast::Pass< core_t >::visit( const ast::CaseStmt * node ) { VISIT_START( node ); @@ -744,6 +763,6 @@ //-------------------------------------------------------------------------- // BranchStmt -template< typename pass_t > -const ast::Stmt * ast::Pass< pass_t >::visit( const ast::BranchStmt * node ) { +template< typename core_t > +const ast::Stmt * ast::Pass< core_t >::visit( const ast::BranchStmt * node ) { VISIT_START( node ); VISIT_END( Stmt, node ); @@ -752,6 +771,6 @@ //-------------------------------------------------------------------------- // ReturnStmt -template< typename pass_t > -const ast::Stmt * ast::Pass< pass_t >::visit( const ast::ReturnStmt * node ) { +template< typename core_t > +const ast::Stmt * ast::Pass< core_t >::visit( const ast::ReturnStmt * node ) { VISIT_START( node ); @@ -765,6 +784,6 @@ //-------------------------------------------------------------------------- // ThrowStmt -template< typename pass_t > -const ast::Stmt * ast::Pass< pass_t >::visit( const ast::ThrowStmt * node ) { +template< typename core_t > +const ast::Stmt * ast::Pass< core_t >::visit( const ast::ThrowStmt * node ) { VISIT_START( node ); @@ -779,6 +798,6 @@ //-------------------------------------------------------------------------- // TryStmt -template< typename pass_t > -const ast::Stmt * ast::Pass< pass_t >::visit( const ast::TryStmt * node ) { +template< typename core_t > +const ast::Stmt * ast::Pass< core_t >::visit( const ast::TryStmt * node ) { VISIT_START( node ); @@ -794,6 +813,6 @@ //-------------------------------------------------------------------------- // CatchStmt -template< typename pass_t > -const ast::Stmt * ast::Pass< pass_t >::visit( const ast::CatchStmt * node ) { +template< typename core_t > +const ast::Stmt * ast::Pass< core_t >::visit( const ast::CatchStmt * node ) { VISIT_START( node ); @@ -811,6 +830,6 @@ //-------------------------------------------------------------------------- // FinallyStmt -template< typename pass_t > -const ast::Stmt * ast::Pass< pass_t >::visit( const ast::FinallyStmt * node ) { +template< typename core_t > +const ast::Stmt * ast::Pass< core_t >::visit( const ast::FinallyStmt * node ) { VISIT_START( node ); @@ -824,6 +843,6 @@ //-------------------------------------------------------------------------- // FinallyStmt -template< typename pass_t > -const ast::Stmt * ast::Pass< pass_t >::visit( const ast::SuspendStmt * node ) { +template< typename core_t > +const ast::Stmt * ast::Pass< core_t >::visit( const ast::SuspendStmt * node ) { VISIT_START( node ); @@ -837,6 +856,6 @@ //-------------------------------------------------------------------------- // WaitForStmt -template< typename pass_t > -const ast::Stmt * ast::Pass< pass_t >::visit( const ast::WaitForStmt * node ) { +template< typename core_t > +const ast::Stmt * ast::Pass< core_t >::visit( const ast::WaitForStmt * node ) { VISIT_START( node ); // for( auto & clause : node->clauses ) { @@ -906,6 +925,6 @@ //-------------------------------------------------------------------------- // WithStmt -template< typename pass_t > -const ast::Decl * ast::Pass< pass_t >::visit( const ast::WithStmt * node ) { +template< typename core_t > +const ast::Decl * ast::Pass< core_t >::visit( const ast::WithStmt * node ) { VISIT_START( node ); @@ -915,5 +934,5 @@ // catch statements introduce a level of scope (for the caught exception) guard_symtab guard { *this }; - __pass::symtab::addWith( pass, 0, node->exprs, node ); + __pass::symtab::addWith( core, 0, node->exprs, node ); maybe_accept( node, &WithStmt::stmt ); } @@ -924,6 +943,6 @@ //-------------------------------------------------------------------------- // NullStmt -template< typename pass_t > -const ast::NullStmt * ast::Pass< pass_t >::visit( const ast::NullStmt * node ) { +template< typename core_t > +const ast::NullStmt * ast::Pass< core_t >::visit( const ast::NullStmt * node ) { VISIT_START( node ); VISIT_END( NullStmt, node ); @@ -932,6 +951,6 @@ //-------------------------------------------------------------------------- // DeclStmt -template< typename pass_t > -const ast::Stmt * ast::Pass< pass_t >::visit( const ast::DeclStmt * node ) { +template< typename core_t > +const ast::Stmt * ast::Pass< core_t >::visit( const ast::DeclStmt * node ) { VISIT_START( node ); @@ -945,13 +964,13 @@ //-------------------------------------------------------------------------- // ImplicitCtorDtorStmt -template< typename pass_t > -const ast::Stmt * ast::Pass< pass_t >::visit( const ast::ImplicitCtorDtorStmt * node ) { +template< typename core_t > +const ast::Stmt * ast::Pass< core_t >::visit( const ast::ImplicitCtorDtorStmt * node ) { VISIT_START( node ); // For now this isn't visited, it is unclear if this causes problem // if all tests are known to pass, remove this code - // VISIT( - // maybe_accept( node, &ImplicitCtorDtorStmt::callStmt ); - // ) + VISIT( + maybe_accept( node, &ImplicitCtorDtorStmt::callStmt ); + ) VISIT_END( Stmt, node ); @@ -960,6 +979,6 @@ //-------------------------------------------------------------------------- // ApplicationExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::ApplicationExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::ApplicationExpr * node ) { VISIT_START( node ); @@ -978,6 +997,6 @@ //-------------------------------------------------------------------------- // UntypedExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::UntypedExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedExpr * node ) { VISIT_START( node ); @@ -996,6 +1015,6 @@ //-------------------------------------------------------------------------- // NameExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::NameExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::NameExpr * node ) { VISIT_START( node ); @@ -1010,6 +1029,6 @@ //-------------------------------------------------------------------------- // CastExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::CastExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::CastExpr * node ) { VISIT_START( node ); @@ -1026,6 +1045,6 @@ //-------------------------------------------------------------------------- // KeywordCastExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::KeywordCastExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::KeywordCastExpr * node ) { VISIT_START( node ); @@ -1042,6 +1061,6 @@ //-------------------------------------------------------------------------- // VirtualCastExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::VirtualCastExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::VirtualCastExpr * node ) { VISIT_START( node ); @@ -1058,6 +1077,6 @@ //-------------------------------------------------------------------------- // AddressExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::AddressExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::AddressExpr * node ) { VISIT_START( node ); @@ -1074,6 +1093,6 @@ //-------------------------------------------------------------------------- // LabelAddressExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::LabelAddressExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::LabelAddressExpr * node ) { VISIT_START( node ); @@ -1088,6 +1107,6 @@ //-------------------------------------------------------------------------- // UntypedMemberExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::UntypedMemberExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedMemberExpr * node ) { VISIT_START( node ); @@ -1105,6 +1124,6 @@ //-------------------------------------------------------------------------- // MemberExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::MemberExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::MemberExpr * node ) { VISIT_START( node ); @@ -1121,6 +1140,6 @@ //-------------------------------------------------------------------------- // VariableExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::VariableExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::VariableExpr * node ) { VISIT_START( node ); @@ -1135,6 +1154,6 @@ //-------------------------------------------------------------------------- // ConstantExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::ConstantExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::ConstantExpr * node ) { VISIT_START( node ); @@ -1149,6 +1168,6 @@ //-------------------------------------------------------------------------- // SizeofExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::SizeofExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::SizeofExpr * node ) { VISIT_START( node ); @@ -1169,6 +1188,6 @@ //-------------------------------------------------------------------------- // AlignofExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::AlignofExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::AlignofExpr * node ) { VISIT_START( node ); @@ -1189,6 +1208,6 @@ //-------------------------------------------------------------------------- // UntypedOffsetofExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::UntypedOffsetofExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedOffsetofExpr * node ) { VISIT_START( node ); @@ -1205,6 +1224,6 @@ //-------------------------------------------------------------------------- // OffsetofExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::OffsetofExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::OffsetofExpr * node ) { VISIT_START( node ); @@ -1221,6 +1240,6 @@ //-------------------------------------------------------------------------- // OffsetPackExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::OffsetPackExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::OffsetPackExpr * node ) { VISIT_START( node ); @@ -1237,6 +1256,6 @@ //-------------------------------------------------------------------------- // LogicalExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::LogicalExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::LogicalExpr * node ) { VISIT_START( node ); @@ -1254,6 +1273,6 @@ //-------------------------------------------------------------------------- // ConditionalExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::ConditionalExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::ConditionalExpr * node ) { VISIT_START( node ); @@ -1272,6 +1291,6 @@ //-------------------------------------------------------------------------- // CommaExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::CommaExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::CommaExpr * node ) { VISIT_START( node ); @@ -1289,6 +1308,6 @@ //-------------------------------------------------------------------------- // TypeExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::TypeExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::TypeExpr * node ) { VISIT_START( node ); @@ -1305,6 +1324,6 @@ //-------------------------------------------------------------------------- // AsmExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::AsmExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::AsmExpr * node ) { VISIT_START( node ); @@ -1322,6 +1341,6 @@ //-------------------------------------------------------------------------- // ImplicitCopyCtorExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::ImplicitCopyCtorExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::ImplicitCopyCtorExpr * node ) { VISIT_START( node ); @@ -1338,6 +1357,6 @@ //-------------------------------------------------------------------------- // ConstructorExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::ConstructorExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::ConstructorExpr * node ) { VISIT_START( node ); @@ -1354,6 +1373,6 @@ //-------------------------------------------------------------------------- // CompoundLiteralExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::CompoundLiteralExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::CompoundLiteralExpr * node ) { VISIT_START( node ); @@ -1370,6 +1389,6 @@ //-------------------------------------------------------------------------- // RangeExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::RangeExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::RangeExpr * node ) { VISIT_START( node ); @@ -1387,6 +1406,6 @@ //-------------------------------------------------------------------------- // UntypedTupleExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::UntypedTupleExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedTupleExpr * node ) { VISIT_START( node ); @@ -1403,6 +1422,6 @@ //-------------------------------------------------------------------------- // TupleExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::TupleExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::TupleExpr * node ) { VISIT_START( node ); @@ -1419,6 +1438,6 @@ //-------------------------------------------------------------------------- // TupleIndexExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::TupleIndexExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::TupleIndexExpr * node ) { VISIT_START( node ); @@ -1435,6 +1454,6 @@ //-------------------------------------------------------------------------- // TupleAssignExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::TupleAssignExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::TupleAssignExpr * node ) { VISIT_START( node ); @@ -1451,15 +1470,15 @@ //-------------------------------------------------------------------------- // StmtExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::StmtExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::StmtExpr * node ) { VISIT_START( node ); VISIT(// don't want statements from outer CompoundStmts to be added to this StmtExpr // get the stmts that will need to be spliced in - auto stmts_before = __pass::stmtsToAddBefore( pass, 0); - auto stmts_after = __pass::stmtsToAddAfter ( pass, 0); + auto stmts_before = __pass::stmtsToAddBefore( core, 0); + auto stmts_after = __pass::stmtsToAddAfter ( core, 0); // These may be modified by subnode but most be restored once we exit this statemnet. - ValueGuardPtr< const ast::TypeSubstitution * > __old_env( __pass::env( pass, 0) ); + ValueGuardPtr< const ast::TypeSubstitution * > __old_env( __pass::env( core, 0) ); ValueGuardPtr< typename std::remove_pointer< decltype(stmts_before) >::type > __old_decls_before( stmts_before ); ValueGuardPtr< typename std::remove_pointer< decltype(stmts_after ) >::type > __old_decls_after ( stmts_after ); @@ -1479,6 +1498,6 @@ //-------------------------------------------------------------------------- // UniqueExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::UniqueExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::UniqueExpr * node ) { VISIT_START( node ); @@ -1495,6 +1514,6 @@ //-------------------------------------------------------------------------- // UntypedInitExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::UntypedInitExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedInitExpr * node ) { VISIT_START( node ); @@ -1512,6 +1531,6 @@ //-------------------------------------------------------------------------- // InitExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::InitExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::InitExpr * node ) { VISIT_START( node ); @@ -1529,6 +1548,6 @@ //-------------------------------------------------------------------------- // DeletedExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::DeletedExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::DeletedExpr * node ) { VISIT_START( node ); @@ -1546,6 +1565,6 @@ //-------------------------------------------------------------------------- // DefaultArgExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::DefaultArgExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::DefaultArgExpr * node ) { VISIT_START( node ); @@ -1562,6 +1581,6 @@ //-------------------------------------------------------------------------- // GenericExpr -template< typename pass_t > -const ast::Expr * ast::Pass< pass_t >::visit( const ast::GenericExpr * node ) { +template< typename core_t > +const ast::Expr * ast::Pass< core_t >::visit( const ast::GenericExpr * node ) { VISIT_START( node ); @@ -1602,6 +1621,6 @@ //-------------------------------------------------------------------------- // VoidType -template< typename pass_t > -const ast::Type * ast::Pass< pass_t >::visit( const ast::VoidType * node ) { +template< typename core_t > +const ast::Type * ast::Pass< core_t >::visit( const ast::VoidType * node ) { VISIT_START( node ); @@ -1611,6 +1630,6 @@ //-------------------------------------------------------------------------- // BasicType -template< typename pass_t > -const ast::Type * ast::Pass< pass_t >::visit( const ast::BasicType * node ) { +template< typename core_t > +const ast::Type * ast::Pass< core_t >::visit( const ast::BasicType * node ) { VISIT_START( node ); @@ -1620,6 +1639,6 @@ //-------------------------------------------------------------------------- // PointerType -template< typename pass_t > -const ast::Type * ast::Pass< pass_t >::visit( const ast::PointerType * node ) { +template< typename core_t > +const ast::Type * ast::Pass< core_t >::visit( const ast::PointerType * node ) { VISIT_START( node ); @@ -1634,6 +1653,6 @@ //-------------------------------------------------------------------------- // ArrayType -template< typename pass_t > -const ast::Type * ast::Pass< pass_t >::visit( const ast::ArrayType * node ) { +template< typename core_t > +const ast::Type * ast::Pass< core_t >::visit( const ast::ArrayType * node ) { VISIT_START( node ); @@ -1648,6 +1667,6 @@ //-------------------------------------------------------------------------- // ReferenceType -template< typename pass_t > -const ast::Type * ast::Pass< pass_t >::visit( const ast::ReferenceType * node ) { +template< typename core_t > +const ast::Type * ast::Pass< core_t >::visit( const ast::ReferenceType * node ) { VISIT_START( node ); @@ -1661,6 +1680,6 @@ //-------------------------------------------------------------------------- // QualifiedType -template< typename pass_t > -const ast::Type * ast::Pass< pass_t >::visit( const ast::QualifiedType * node ) { +template< typename core_t > +const ast::Type * ast::Pass< core_t >::visit( const ast::QualifiedType * node ) { VISIT_START( node ); @@ -1675,13 +1694,14 @@ //-------------------------------------------------------------------------- // FunctionType -template< typename pass_t > -const ast::Type * ast::Pass< pass_t >::visit( const ast::FunctionType * node ) { - VISIT_START( node ); - - VISIT( - maybe_accept( node, &FunctionType::forall ); +template< typename core_t > +const ast::Type * ast::Pass< core_t >::visit( const ast::FunctionType * node ) { + VISIT_START( node ); + + VISIT({ + guard_forall_subs forall_guard { *this, node }; + mutate_forall( node ); maybe_accept( node, &FunctionType::returns ); maybe_accept( node, &FunctionType::params ); - ) + }) VISIT_END( Type, node ); @@ -1690,13 +1710,14 @@ //-------------------------------------------------------------------------- // StructInstType -template< typename pass_t > -const ast::Type * ast::Pass< pass_t >::visit( const ast::StructInstType * node ) { - VISIT_START( node ); - - __pass::symtab::addStruct( pass, 0, node->name ); +template< typename core_t > +const ast::Type * ast::Pass< core_t >::visit( const ast::StructInstType * node ) { + VISIT_START( node ); + + __pass::symtab::addStruct( core, 0, node->name ); VISIT({ guard_symtab guard { *this }; - maybe_accept( node, &StructInstType::forall ); + guard_forall_subs forall_guard { *this, node }; + mutate_forall( node ); maybe_accept( node, &StructInstType::params ); }) @@ -1707,15 +1728,16 @@ //-------------------------------------------------------------------------- // UnionInstType -template< typename pass_t > -const ast::Type * ast::Pass< pass_t >::visit( const ast::UnionInstType * node ) { - VISIT_START( node ); - - __pass::symtab::addStruct( pass, 0, node->name ); - - { +template< typename core_t > +const ast::Type * ast::Pass< core_t >::visit( const ast::UnionInstType * node ) { + VISIT_START( node ); + + __pass::symtab::addUnion( core, 0, node->name ); + + VISIT({ guard_symtab guard { *this }; - maybe_accept( node, &UnionInstType::forall ); + guard_forall_subs forall_guard { *this, node }; + mutate_forall( node ); maybe_accept( node, &UnionInstType::params ); - } + }) VISIT_END( Type, node ); @@ -1724,12 +1746,13 @@ //-------------------------------------------------------------------------- // EnumInstType -template< typename pass_t > -const ast::Type * ast::Pass< pass_t >::visit( const ast::EnumInstType * node ) { - VISIT_START( node ); - - VISIT( - maybe_accept( node, &EnumInstType::forall ); +template< typename core_t > +const ast::Type * ast::Pass< core_t >::visit( const ast::EnumInstType * node ) { + VISIT_START( node ); + + VISIT({ + guard_forall_subs forall_guard { *this, node }; + mutate_forall( node ); maybe_accept( node, &EnumInstType::params ); - ) + }) VISIT_END( Type, node ); @@ -1738,12 +1761,13 @@ //-------------------------------------------------------------------------- // TraitInstType -template< typename pass_t > -const ast::Type * ast::Pass< pass_t >::visit( const ast::TraitInstType * node ) { - VISIT_START( node ); - - VISIT( - maybe_accept( node, &TraitInstType::forall ); +template< typename core_t > +const ast::Type * ast::Pass< core_t >::visit( const ast::TraitInstType * node ) { + VISIT_START( node ); + + VISIT({ + guard_forall_subs forall_guard { *this, node }; + mutate_forall( node ); maybe_accept( node, &TraitInstType::params ); - ) + }) VISIT_END( Type, node ); @@ -1752,11 +1776,16 @@ //-------------------------------------------------------------------------- // TypeInstType -template< typename pass_t > -const ast::Type * ast::Pass< pass_t >::visit( const ast::TypeInstType * node ) { - VISIT_START( node ); - - VISIT( - maybe_accept( node, &TypeInstType::forall ); - maybe_accept( node, &TypeInstType::params ); +template< typename core_t > +const ast::Type * ast::Pass< core_t >::visit( const ast::TypeInstType * node ) { + VISIT_START( node ); + + VISIT( + { + guard_forall_subs forall_guard { *this, node }; + mutate_forall( node ); + maybe_accept( node, &TypeInstType::params ); + } + // ensure that base re-bound if doing substitution + __pass::forall::replace( core, 0, node ); ) @@ -1766,6 +1795,6 @@ //-------------------------------------------------------------------------- // TupleType -template< typename pass_t > -const ast::Type * ast::Pass< pass_t >::visit( const ast::TupleType * node ) { +template< typename core_t > +const ast::Type * ast::Pass< core_t >::visit( const ast::TupleType * node ) { VISIT_START( node ); @@ -1780,6 +1809,6 @@ //-------------------------------------------------------------------------- // TypeofType -template< typename pass_t > -const ast::Type * ast::Pass< pass_t >::visit( const ast::TypeofType * node ) { +template< typename core_t > +const ast::Type * ast::Pass< core_t >::visit( const ast::TypeofType * node ) { VISIT_START( node ); @@ -1793,6 +1822,6 @@ //-------------------------------------------------------------------------- // VarArgsType -template< typename pass_t > -const ast::Type * ast::Pass< pass_t >::visit( const ast::VarArgsType * node ) { +template< typename core_t > +const ast::Type * ast::Pass< core_t >::visit( const ast::VarArgsType * node ) { VISIT_START( node ); @@ -1802,6 +1831,6 @@ //-------------------------------------------------------------------------- // ZeroType -template< typename pass_t > -const ast::Type * ast::Pass< pass_t >::visit( const ast::ZeroType * node ) { +template< typename core_t > +const ast::Type * ast::Pass< core_t >::visit( const ast::ZeroType * node ) { VISIT_START( node ); @@ -1811,6 +1840,6 @@ //-------------------------------------------------------------------------- // OneType -template< typename pass_t > -const ast::Type * ast::Pass< pass_t >::visit( const ast::OneType * node ) { +template< typename core_t > +const ast::Type * ast::Pass< core_t >::visit( const ast::OneType * node ) { VISIT_START( node ); @@ -1820,6 +1849,6 @@ //-------------------------------------------------------------------------- // GlobalScopeType -template< typename pass_t > -const ast::Type * ast::Pass< pass_t >::visit( const ast::GlobalScopeType * node ) { +template< typename core_t > +const ast::Type * ast::Pass< core_t >::visit( const ast::GlobalScopeType * node ) { VISIT_START( node ); @@ -1830,6 +1859,6 @@ //-------------------------------------------------------------------------- // Designation -template< typename pass_t > -const ast::Designation * ast::Pass< pass_t >::visit( const ast::Designation * node ) { +template< typename core_t > +const ast::Designation * ast::Pass< core_t >::visit( const ast::Designation * node ) { VISIT_START( node ); @@ -1841,6 +1870,6 @@ //-------------------------------------------------------------------------- // SingleInit -template< typename pass_t > -const ast::Init * ast::Pass< pass_t >::visit( const ast::SingleInit * node ) { +template< typename core_t > +const ast::Init * ast::Pass< core_t >::visit( const ast::SingleInit * node ) { VISIT_START( node ); @@ -1854,6 +1883,6 @@ //-------------------------------------------------------------------------- // ListInit -template< typename pass_t > -const ast::Init * ast::Pass< pass_t >::visit( const ast::ListInit * node ) { +template< typename core_t > +const ast::Init * ast::Pass< core_t >::visit( const ast::ListInit * node ) { VISIT_START( node ); @@ -1868,6 +1897,6 @@ //-------------------------------------------------------------------------- // ConstructorInit -template< typename pass_t > -const ast::Init * ast::Pass< pass_t >::visit( const ast::ConstructorInit * node ) { +template< typename core_t > +const ast::Init * ast::Pass< core_t >::visit( const ast::ConstructorInit * node ) { VISIT_START( node ); @@ -1883,6 +1912,6 @@ //-------------------------------------------------------------------------- // Attribute -template< typename pass_t > -const ast::Attribute * ast::Pass< pass_t >::visit( const ast::Attribute * node ) { +template< typename core_t > +const ast::Attribute * ast::Pass< core_t >::visit( const ast::Attribute * node ) { VISIT_START( node ); @@ -1896,6 +1925,6 @@ //-------------------------------------------------------------------------- // TypeSubstitution -template< typename pass_t > -const ast::TypeSubstitution * ast::Pass< pass_t >::visit( const ast::TypeSubstitution * node ) { +template< typename core_t > +const ast::TypeSubstitution * ast::Pass< core_t >::visit( const ast::TypeSubstitution * node ) { VISIT_START( node ); @@ -1907,5 +1936,5 @@ guard_symtab guard { *this }; auto new_node = p.second->accept( *this ); - if (new_node != p.second) mutated = false; + if (new_node != p.second) mutated = true; new_map.insert({ p.first, new_node }); } @@ -1923,5 +1952,5 @@ guard_symtab guard { *this }; auto new_node = p.second->accept( *this ); - if (new_node != p.second) mutated = false; + if (new_node != p.second) mutated = true; new_map.insert({ p.first, new_node }); } Index: src/AST/Pass.proto.hpp =================================================================== --- src/AST/Pass.proto.hpp (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/AST/Pass.proto.hpp (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -17,6 +17,8 @@ // IWYU pragma: private, include "Pass.hpp" +#include "Common/Stats/Heap.h" + namespace ast { -template +template class Pass; @@ -82,5 +84,5 @@ }; - std::stack< cleanup_t > cleanups; + std::stack< cleanup_t, std::vector > cleanups; }; @@ -111,7 +113,7 @@ /// "Short hand" to check if this is a valid previsit function /// Mostly used to make the static_assert look (and print) prettier - template + template struct is_valid_previsit { - using ret_t = decltype( ((pass_t*)nullptr)->previsit( (const node_t *)nullptr ) ); + using ret_t = decltype( ((core_t*)nullptr)->previsit( (const node_t *)nullptr ) ); static constexpr bool value = std::is_void< ret_t >::value || @@ -127,7 +129,7 @@ template<> struct __assign { - template - static inline void result( pass_t & pass, const node_t * & node ) { - pass.previsit( node ); + template + static inline void result( core_t & core, const node_t * & node ) { + core.previsit( node ); } }; @@ -135,7 +137,7 @@ template<> struct __assign { - template - static inline void result( pass_t & pass, const node_t * & node ) { - node = pass.previsit( node ); + template + static inline void result( core_t & core, const node_t * & node ) { + node = core.previsit( node ); assertf(node, "Previsit must not return NULL"); } @@ -150,7 +152,7 @@ template<> struct __return { - template - static inline const node_t * result( pass_t & pass, const node_t * & node ) { - pass.postvisit( node ); + template + static inline const node_t * result( core_t & core, const node_t * & node ) { + core.postvisit( node ); return node; } @@ -159,7 +161,7 @@ template<> struct __return { - template - static inline auto result( pass_t & pass, const node_t * & node ) { - return pass.postvisit( node ); + template + static inline auto result( core_t & core, const node_t * & node ) { + return core.postvisit( node ); } }; @@ -180,8 +182,8 @@ //------------------------------------------------------------------------------------------------------------------------------------------------------------------------- // PreVisit : may mutate the pointer passed in if the node is mutated in the previsit call - template - static inline auto previsit( pass_t & pass, const node_t * & node, int ) -> decltype( pass.previsit( node ), void() ) { + template + static inline auto previsit( core_t & core, const node_t * & node, int ) -> decltype( core.previsit( node ), void() ) { static_assert( - is_valid_previsit::value, + is_valid_previsit::value, "Previsit may not change the type of the node. It must return its paremeter or void." ); @@ -189,26 +191,26 @@ __assign< std::is_void< - decltype( pass.previsit( node ) ) + decltype( core.previsit( node ) ) >::value - >::result( pass, node ); + >::result( core, node ); } - template - static inline auto previsit( pass_t &, const node_t *, long ) {} + template + static inline auto previsit( core_t &, const node_t *, long ) {} // PostVisit : never mutates the passed pointer but may return a different node - template - static inline auto postvisit( pass_t & pass, const node_t * node, int ) -> - decltype( pass.postvisit( node ), node->accept( *(Visitor*)nullptr ) ) + template + static inline auto postvisit( core_t & core, const node_t * node, int ) -> + decltype( core.postvisit( node ), node->accept( *(Visitor*)nullptr ) ) { return __return< std::is_void< - decltype( pass.postvisit( node ) ) + decltype( core.postvisit( node ) ) >::value - >::result( pass, node ); + >::result( core, node ); } - template - static inline const node_t * postvisit( pass_t &, const node_t * node, long ) { return node; } + template + static inline const node_t * postvisit( core_t &, const node_t * node, long ) { return node; } //------------------------------------------------------------------------------------------------------------------------------------------------------------------------- @@ -225,9 +227,9 @@ // The type is not strictly enforced but does match the accessory #define FIELD_PTR( name, default_type ) \ - template< typename pass_t > \ - static inline auto name( pass_t & pass, int ) -> decltype( &pass.name ) { return &pass.name; } \ + template< typename core_t > \ + static inline auto name( core_t & core, int ) -> decltype( &core.name ) { return &core.name; } \ \ - template< typename pass_t > \ - static inline default_type * name( pass_t &, long ) { return nullptr; } + template< typename core_t > \ + static inline default_type * name( core_t &, long ) { return nullptr; } // List of fields and their expected types @@ -239,8 +241,24 @@ FIELD_PTR( visit_children, __pass::bool_ref ) FIELD_PTR( at_cleanup, __pass::at_cleanup_t ) - FIELD_PTR( visitor, ast::Pass * const ) + FIELD_PTR( visitor, ast::Pass * const ) // Remove the macro to make sure we don't clash #undef FIELD_PTR + + template< typename core_t > + static inline auto beginTrace(core_t &, int) -> decltype( core_t::traceId, void() ) { + // Stats::Heap::stacktrace_push(core_t::traceId); + } + + template< typename core_t > + static inline auto endTrace(core_t &, int) -> decltype( core_t::traceId, void() ) { + // Stats::Heap::stacktrace_pop(); + } + + template< typename core_t > + static void beginTrace(core_t &, long) {} + + template< typename core_t > + static void endTrace(core_t &, long) {} // Another feature of the templated visitor is that it calls beginScope()/endScope() for compound statement. @@ -248,60 +266,60 @@ // detect it using the same strategy namespace scope { - template - static inline auto enter( pass_t & pass, int ) -> decltype( pass.beginScope(), void() ) { - pass.beginScope(); - } - - template - static inline void enter( pass_t &, long ) {} - - template - static inline auto leave( pass_t & pass, int ) -> decltype( pass.endScope(), void() ) { - pass.endScope(); - } - - template - static inline void leave( pass_t &, long ) {} - }; - - // Finally certain pass desire an up to date symbol table automatically + template + static inline auto enter( core_t & core, int ) -> decltype( core.beginScope(), void() ) { + core.beginScope(); + } + + template + static inline void enter( core_t &, long ) {} + + template + static inline auto leave( core_t & core, int ) -> decltype( core.endScope(), void() ) { + core.endScope(); + } + + template + static inline void leave( core_t &, long ) {} + } // namespace scope + + // Certain passes desire an up to date symbol table automatically // detect the presence of a member name `symtab` and call all the members appropriately namespace symtab { // Some simple scoping rules - template - static inline auto enter( pass_t & pass, int ) -> decltype( pass.symtab.enterScope(), void() ) { - pass.symtab.enterScope(); - } - - template - static inline auto enter( pass_t &, long ) {} - - template - static inline auto leave( pass_t & pass, int ) -> decltype( pass.symtab.leaveScope(), void() ) { - pass.symtab.leaveScope(); - } - - template - static inline auto leave( pass_t &, long ) {} + template + static inline auto enter( core_t & core, int ) -> decltype( core.symtab, void() ) { + core.symtab.enterScope(); + } + + template + static inline auto enter( core_t &, long ) {} + + template + static inline auto leave( core_t & core, int ) -> decltype( core.symtab, void() ) { + core.symtab.leaveScope(); + } + + template + static inline auto leave( core_t &, long ) {} // The symbol table has 2 kind of functions mostly, 1 argument and 2 arguments // Create macro to condense these common patterns #define SYMTAB_FUNC1( func, type ) \ - template \ - static inline auto func( pass_t & pass, int, type arg ) -> decltype( pass.symtab.func( arg ), void() ) {\ - pass.symtab.func( arg ); \ + template \ + static inline auto func( core_t & core, int, type arg ) -> decltype( core.symtab.func( arg ), void() ) {\ + core.symtab.func( arg ); \ } \ \ - template \ - static inline void func( pass_t &, long, type ) {} + template \ + static inline void func( core_t &, long, type ) {} #define SYMTAB_FUNC2( func, type1, type2 ) \ - template \ - static inline auto func( pass_t & pass, int, type1 arg1, type2 arg2 ) -> decltype( pass.symtab.func( arg1, arg2 ), void () ) {\ - pass.symtab.func( arg1, arg2 ); \ + template \ + static inline auto func( core_t & core, int, type1 arg1, type2 arg2 ) -> decltype( core.symtab.func( arg1, arg2 ), void () ) {\ + core.symtab.func( arg1, arg2 ); \ } \ \ - template \ - static inline void func( pass_t &, long, type1, type2 ) {} + template \ + static inline void func( core_t &, long, type1, type2 ) {} SYMTAB_FUNC1( addId , const DeclWithType * ); @@ -311,50 +329,94 @@ SYMTAB_FUNC1( addUnion , const UnionDecl * ); SYMTAB_FUNC1( addTrait , const TraitDecl * ); - SYMTAB_FUNC2( addWith , const std::vector< ptr > &, const Node * ); + SYMTAB_FUNC2( addWith , const std::vector< ptr > &, const Decl * ); // A few extra functions have more complicated behaviour, they are hand written - template - static inline auto addStructFwd( pass_t & pass, int, const ast::StructDecl * decl ) -> decltype( pass.symtab.addStruct( decl ), void() ) { + template + static inline auto addStructFwd( core_t & core, int, const ast::StructDecl * decl ) -> decltype( core.symtab.addStruct( decl ), void() ) { ast::StructDecl * fwd = new ast::StructDecl( decl->location, decl->name ); fwd->params = decl->params; - pass.symtab.addStruct( fwd ); - } - - template - static inline void addStructFwd( pass_t &, long, const ast::StructDecl * ) {} - - template - static inline auto addUnionFwd( pass_t & pass, int, const ast::UnionDecl * decl ) -> decltype( pass.symtab.addUnion( decl ), void() ) { + core.symtab.addStruct( fwd ); + } + + template + static inline void addStructFwd( core_t &, long, const ast::StructDecl * ) {} + + template + static inline auto addUnionFwd( core_t & core, int, const ast::UnionDecl * decl ) -> decltype( core.symtab.addUnion( decl ), void() ) { UnionDecl * fwd = new UnionDecl( decl->location, decl->name ); fwd->params = decl->params; - pass.symtab.addUnion( fwd ); - } - - template - static inline void addUnionFwd( pass_t &, long, const ast::UnionDecl * ) {} - - template - static inline auto addStruct( pass_t & pass, int, const std::string & str ) -> decltype( pass.symtab.addStruct( str ), void() ) { - if ( ! pass.symtab.lookupStruct( str ) ) { - pass.symtab.addStruct( str ); + core.symtab.addUnion( fwd ); + } + + template + static inline void addUnionFwd( core_t &, long, const ast::UnionDecl * ) {} + + template + static inline auto addStruct( core_t & core, int, const std::string & str ) -> decltype( core.symtab.addStruct( str ), void() ) { + if ( ! core.symtab.lookupStruct( str ) ) { + core.symtab.addStruct( str ); } } - template - static inline void addStruct( pass_t &, long, const std::string & ) {} - - template - static inline auto addUnion( pass_t & pass, int, const std::string & str ) -> decltype( pass.symtab.addUnion( str ), void() ) { - if ( ! pass.symtab.lookupUnion( str ) ) { - pass.symtab.addUnion( str ); + template + static inline void addStruct( core_t &, long, const std::string & ) {} + + template + static inline auto addUnion( core_t & core, int, const std::string & str ) -> decltype( core.symtab.addUnion( str ), void() ) { + if ( ! core.symtab.lookupUnion( str ) ) { + core.symtab.addUnion( str ); } } - template - static inline void addUnion( pass_t &, long, const std::string & ) {} + template + static inline void addUnion( core_t &, long, const std::string & ) {} #undef SYMTAB_FUNC1 #undef SYMTAB_FUNC2 - }; -}; -}; + } // namespace symtab + + // Some passes need to mutate TypeDecl and properly update their pointing TypeInstType. + // Detect the presence of a member name `subs` and call all members appropriately + namespace forall { + // Some simple scoping rules + template + static inline auto enter( core_t & core, int, const ast::ParameterizedType * type ) + -> decltype( core.subs, void() ) { + if ( ! type->forall.empty() ) core.subs.beginScope(); + } + + template + static inline auto enter( core_t &, long, const ast::ParameterizedType * ) {} + + template + static inline auto leave( core_t & core, int, const ast::ParameterizedType * type ) + -> decltype( core.subs, void() ) { + if ( ! type->forall.empty() ) { core.subs.endScope(); } + } + + template + static inline auto leave( core_t &, long, const ast::ParameterizedType * ) {} + + // Get the substitution table, if present + template + static inline auto subs( core_t & core, int ) -> decltype( &core.subs ) { + return &core.subs; + } + + template + static inline ast::ForallSubstitutionTable * subs( core_t &, long ) { return nullptr; } + + // Replaces a TypeInstType's base TypeDecl according to the table + template + static inline auto replace( core_t & core, int, const ast::TypeInstType *& inst ) + -> decltype( core.subs, void() ) { + inst = ast::mutate_field( + inst, &ast::TypeInstType::base, core.subs.replace( inst->base ) ); + } + + template + static inline auto replace( core_t &, long, const ast::TypeInstType *& ) {} + + } // namespace forall +} // namespace __pass +} // namespace ast Index: src/AST/Print.cpp =================================================================== --- src/AST/Print.cpp (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/AST/Print.cpp (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -29,6 +29,5 @@ template -constexpr auto make_array(T&&... values) -> - array +constexpr array make_array(T&&... values) { return array{ @@ -129,23 +128,18 @@ void print( const ast::Expr::InferUnion & inferred, unsigned level = 0 ) { - switch ( inferred.mode ) { - case ast::Expr::InferUnion::Empty: return; - case ast::Expr::InferUnion::Slots: { - os << indent << "with " << inferred.data.resnSlots.size() + if (inferred.data.resnSlots && !inferred.data.resnSlots->empty()) { + os << indent << "with " << inferred.data.resnSlots->size() << " pending inference slots" << endl; - return; - } - case ast::Expr::InferUnion::Params: { + } + if (inferred.data.inferParams && !inferred.data.inferParams->empty()) { os << indent << "with inferred parameters " << level << ":" << endl; ++indent; - for ( const auto & i : inferred.data.inferParams ) { + for ( const auto & i : *inferred.data.inferParams ) { os << indent; - short_print( Decl::fromId( i.second.decl ) ); + short_print( i.second.declptr ); os << endl; print( i.second.expr->inferred, level+1 ); } --indent; - return; - } } } @@ -233,5 +227,5 @@ } - if ( ! short_mode && ! node->assertions.empty() ) { + if ( ! node->assertions.empty() ) { os << endl << indent << "... with assertions" << endl; ++indent; @@ -842,5 +836,5 @@ virtual const ast::Expr * visit( const ast::CastExpr * node ) override final { ++indent; - os << (node->isGenerated ? "Generated" : "Explicit") << " cast of:" << endl << indent; + os << (node->isGenerated ? "Generated" : "Explicit") << " Cast of:" << endl << indent; safe_print( node->arg ); os << endl << indent-1 << "... to:"; Index: src/AST/Stmt.hpp =================================================================== --- src/AST/Stmt.hpp (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/AST/Stmt.hpp (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -27,5 +27,7 @@ // Must be included in *all* AST classes; should be #undef'd at the end of the file -#define MUTATE_FRIEND template friend node_t * mutate(const node_t * node); +#define MUTATE_FRIEND \ + template friend node_t * mutate(const node_t * node); \ + template friend node_t * shallowCopy(const node_t * node); namespace ast { @@ -412,5 +414,5 @@ class ImplicitCtorDtorStmt final : public Stmt { public: - readonly callStmt; + ptr callStmt; ImplicitCtorDtorStmt( const CodeLocation & loc, const Stmt * callStmt, Index: src/AST/Type.cpp =================================================================== --- src/AST/Type.cpp (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/AST/Type.cpp (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -9,7 +9,7 @@ // Author : Aaron B. Moss // Created On : Mon May 13 15:00:00 2019 -// Last Modified By : Peter A. Buhr -// Last Modified On : Sun Dec 15 16:56:28 2019 -// Update Count : 4 +// Last Modified By : Andrew Beach +// Last Modified On : Thu Jul 23 14:16:00 2020 +// Update Count : 5 // @@ -21,5 +21,7 @@ #include "Decl.hpp" +#include "ForallSubstitutor.hpp" // for substituteForall #include "Init.hpp" +#include "Common/utility.h" // for copy, move #include "InitTweak/InitTweak.h" // for getPointerBase #include "Tuples/Tuples.h" // for isTtype @@ -90,5 +92,22 @@ // GENERATED END +// --- ParameterizedType + +void ParameterizedType::initWithSub( + const ParameterizedType & o, Pass< ForallSubstitutor > & sub +) { + forall = sub.core( o.forall ); +} + // --- FunctionType + +FunctionType::FunctionType( const FunctionType & o ) +: ParameterizedType( o.qualifiers, copy( o.attributes ) ), returns(), params(), + isVarArgs( o.isVarArgs ) { + Pass< ForallSubstitutor > sub; + initWithSub( o, sub ); // initialize substitution map + returns = sub.core( o.returns ); // apply to return and parameter types + params = sub.core( o.params ); +} namespace { @@ -106,4 +125,17 @@ // --- ReferenceToType + +void ReferenceToType::initWithSub( const ReferenceToType & o, Pass< ForallSubstitutor > & sub ) { + ParameterizedType::initWithSub( o, sub ); // initialize substitution + params = sub.core( o.params ); // apply to parameters +} + +ReferenceToType::ReferenceToType( const ReferenceToType & o ) +: ParameterizedType( o.qualifiers, copy( o.attributes ) ), params(), name( o.name ), + hoistType( o.hoistType ) { + Pass< ForallSubstitutor > sub; + initWithSub( o, sub ); +} + std::vector> ReferenceToType::lookup( const std::string& name ) const { assertf( aggr(), "Must have aggregate to perform lookup" ); @@ -116,35 +148,34 @@ } -// --- StructInstType - -StructInstType::StructInstType( const StructDecl * b, CV::Qualifiers q, - std::vector>&& as ) -: ReferenceToType( b->name, q, std::move(as) ), base( b ) {} - -bool StructInstType::isComplete() const { return base ? base->body : false; } - -// --- UnionInstType - -UnionInstType::UnionInstType( const UnionDecl * b, CV::Qualifiers q, - std::vector>&& as ) -: ReferenceToType( b->name, q, std::move(as) ), base( b ) {} - -bool UnionInstType::isComplete() const { return base ? base->body : false; } - -// --- EnumInstType - -EnumInstType::EnumInstType( const EnumDecl * b, CV::Qualifiers q, - std::vector>&& as ) -: ReferenceToType( b->name, q, std::move(as) ), base( b ) {} - -bool EnumInstType::isComplete() const { return base ? base->body : false; } +// --- SueInstType (StructInstType, UnionInstType, EnumInstType) + +template +SueInstType::SueInstType( + const decl_t * b, CV::Qualifiers q, std::vector>&& as ) +: ReferenceToType( b->name, q, move(as) ), base( b ) {} + +template +bool SueInstType::isComplete() const { + return base ? base->body : false; +} + +template class SueInstType; +template class SueInstType; +template class SueInstType; // --- TraitInstType -TraitInstType::TraitInstType( const TraitDecl * b, CV::Qualifiers q, - std::vector>&& as ) -: ReferenceToType( b->name, q, std::move(as) ), base( b ) {} +TraitInstType::TraitInstType( + const TraitDecl * b, CV::Qualifiers q, std::vector>&& as ) +: ReferenceToType( b->name, q, move(as) ), base( b ) {} // --- TypeInstType + +TypeInstType::TypeInstType( const TypeInstType & o ) +: ReferenceToType( o.name, o.qualifiers, copy( o.attributes ) ), base(), kind( o.kind ) { + Pass< ForallSubstitutor > sub; + initWithSub( o, sub ); // initialize substitution + base = sub.core( o.base ); // apply to base type +} void TypeInstType::set_base( const TypeDecl * b ) { @@ -158,5 +189,5 @@ TupleType::TupleType( std::vector> && ts, CV::Qualifiers q ) -: Type( q ), types( std::move(ts) ), members() { +: Type( q ), types( move(ts) ), members() { // This constructor is awkward. `TupleType` needs to contain objects so that members can be // named, but members without initializer nodes end up getting constructors, which breaks Index: src/AST/Type.hpp =================================================================== --- src/AST/Type.hpp (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/AST/Type.hpp (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -9,7 +9,7 @@ // Author : Aaron B. Moss // Created On : Thu May 9 10:00:00 2019 -// Last Modified By : Peter A. Buhr -// Last Modified On : Wed Dec 11 21:56:46 2019 -// Update Count : 5 +// Last Modified By : Andrew Beach +// Last Modified On : Thu Jul 23 14:15:00 2020 +// Update Count : 6 // @@ -29,7 +29,13 @@ // Must be included in *all* AST classes; should be #undef'd at the end of the file -#define MUTATE_FRIEND template friend node_t * mutate(const node_t * node); +#define MUTATE_FRIEND \ + template friend node_t * mutate(const node_t * node); \ + template friend node_t * shallowCopy(const node_t * node); namespace ast { + +template< typename T > class Pass; + +struct ForallSubstitutor; class Type : public Node { @@ -44,5 +50,4 @@ bool is_volatile() const { return qualifiers.is_volatile; } bool is_restrict() const { return qualifiers.is_restrict; } - bool is_lvalue() const { return qualifiers.is_lvalue; } bool is_mutex() const { return qualifiers.is_mutex; } bool is_atomic() const { return qualifiers.is_atomic; } @@ -51,5 +56,4 @@ Type * set_volatile( bool v ) { qualifiers.is_volatile = v; return this; } Type * set_restrict( bool v ) { qualifiers.is_restrict = v; return this; } - Type * set_lvalue( bool v ) { qualifiers.is_lvalue = v; return this; } Type * set_mutex( bool v ) { qualifiers.is_mutex = v; return this; } Type * set_atomic( bool v ) { qualifiers.is_atomic = v; return this; } @@ -163,5 +167,5 @@ static const char *typeNames[]; - BasicType( Kind k, CV::Qualifiers q = {}, std::vector> && as = {} ) + BasicType( Kind k, CV::Qualifiers q = {}, std::vector> && as = {} ) : Type(q, std::move(as)), kind(k) {} @@ -265,4 +269,7 @@ /// Base type for potentially forall-qualified types class ParameterizedType : public Type { +protected: + /// initializes forall with substitutor + void initWithSub( const ParameterizedType & o, Pass< ForallSubstitutor > & sub ); public: using ForallList = std::vector>; @@ -276,4 +283,11 @@ ParameterizedType( CV::Qualifiers q, std::vector> && as = {} ) : Type(q, std::move(as)), forall() {} + + // enforce use of ForallSubstitutor to copy parameterized type + ParameterizedType( const ParameterizedType & ) = delete; + + ParameterizedType( ParameterizedType && ) = default; + + // no need to change destructor, and operator= deleted in Node private: @@ -301,4 +315,6 @@ : ParameterizedType(q), returns(), params(), isVarArgs(va) {} + FunctionType( const FunctionType & o ); + /// true if either the parameters or return values contain a tttype bool isTtype() const; @@ -314,4 +330,7 @@ /// base class for types that refer to types declared elsewhere (aggregates and typedefs) class ReferenceToType : public ParameterizedType { +protected: + /// Initializes forall and parameters based on substitutor + void initWithSub( const ReferenceToType & o, Pass< ForallSubstitutor > & sub ); public: std::vector> params; @@ -319,7 +338,9 @@ bool hoistType = false; - ReferenceToType( const std::string& n, CV::Qualifiers q = {}, - std::vector> && as = {} ) + ReferenceToType( + const std::string& n, CV::Qualifiers q = {}, std::vector> && as = {} ) : ParameterizedType(q, std::move(as)), params(), name(n) {} + + ReferenceToType( const ReferenceToType & o ); /// Gets aggregate declaration this type refers to @@ -333,77 +354,48 @@ }; -/// instance of struct type -class StructInstType final : public ReferenceToType { -public: - readonly base; - - StructInstType( const std::string& n, CV::Qualifiers q = {}, - std::vector> && as = {} ) +// Common implementation for the SUE instance types. Not to be used directly. +template +class SueInstType final : public ReferenceToType { +public: + using base_type = decl_t; + readonly base; + + SueInstType( + const std::string& n, CV::Qualifiers q = {}, std::vector> && as = {} ) : ReferenceToType( n, q, std::move(as) ), base() {} - StructInstType( const StructDecl * b, CV::Qualifiers q = {}, - std::vector> && as = {} ); + + SueInstType( + const decl_t * b, CV::Qualifiers q = {}, std::vector> && as = {} ); bool isComplete() const override; - const StructDecl * aggr() const override { return base; } - - const Type * accept( Visitor & v ) const override { return v.visit( this ); } -private: - StructInstType * clone() const override { return new StructInstType{ *this }; } - MUTATE_FRIEND -}; - -/// instance of union type -class UnionInstType final : public ReferenceToType { -public: - readonly base; - - UnionInstType( const std::string& n, CV::Qualifiers q = {}, - std::vector> && as = {} ) + const decl_t * aggr() const override { return base; } + + const Type * accept( Visitor & v ) const override { return v.visit( this ); } +private: + SueInstType * clone() const override { return new SueInstType{ *this }; } + MUTATE_FRIEND +}; + +/// An instance of a struct type. +using StructInstType = SueInstType; + +/// An instance of a union type. +using UnionInstType = SueInstType; + +/// An instance of an enum type. +using EnumInstType = SueInstType; + +/// An instance of a trait type. +class TraitInstType final : public ReferenceToType { +public: + readonly base; + + TraitInstType( + const std::string& n, CV::Qualifiers q = {}, std::vector> && as = {} ) : ReferenceToType( n, q, std::move(as) ), base() {} - UnionInstType( const UnionDecl * b, CV::Qualifiers q = {}, - std::vector> && as = {} ); - - bool isComplete() const override; - - const UnionDecl * aggr() const override { return base; } - - const Type * accept( Visitor & v ) const override { return v.visit( this ); } -private: - UnionInstType * clone() const override { return new UnionInstType{ *this }; } - MUTATE_FRIEND -}; - -/// instance of enum type -class EnumInstType final : public ReferenceToType { -public: - readonly base; - - EnumInstType( const std::string& n, CV::Qualifiers q = {}, - std::vector> && as = {} ) - : ReferenceToType( n, q, std::move(as) ), base() {} - EnumInstType( const EnumDecl * b, CV::Qualifiers q = {}, - std::vector> && as = {} ); - - bool isComplete() const override; - - const EnumDecl * aggr() const override { return base; } - - const Type * accept( Visitor & v ) const override { return v.visit( this ); } -private: - EnumInstType * clone() const override { return new EnumInstType{ *this }; } - MUTATE_FRIEND -}; - -/// instance of trait type -class TraitInstType final : public ReferenceToType { -public: - readonly base; - - TraitInstType( const std::string& n, CV::Qualifiers q = {}, - std::vector> && as = {} ) - : ReferenceToType( n, q, std::move(as) ), base() {} - TraitInstType( const TraitDecl * b, CV::Qualifiers q = {}, - std::vector> && as = {} ); + + TraitInstType( + const TraitDecl * b, CV::Qualifiers q = {}, std::vector> && as = {} ); // not meaningful for TraitInstType @@ -424,5 +416,6 @@ TypeDecl::Kind kind; - TypeInstType( const std::string& n, const TypeDecl * b, CV::Qualifiers q = {}, + TypeInstType( + const std::string& n, const TypeDecl * b, CV::Qualifiers q = {}, std::vector> && as = {} ) : ReferenceToType( n, q, std::move(as) ), base( b ), kind( b->kind ) {} @@ -431,4 +424,6 @@ : ReferenceToType( n, q, std::move(as) ), base(), kind( k ) {} + TypeInstType( const TypeInstType & o ); + /// sets `base`, updating `kind` correctly void set_base( const TypeDecl * ); Index: src/AST/TypeEnvironment.cpp =================================================================== --- src/AST/TypeEnvironment.cpp (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/AST/TypeEnvironment.cpp (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -59,5 +59,5 @@ std::copy( clz.vars.begin(), clz.vars.end(), std::ostream_iterator< std::string >( out, " " ) ); out << ")"; - + if ( clz.bound ) { out << " -> "; @@ -92,5 +92,5 @@ } } - + i = next; // go to next node even if this removed } @@ -161,9 +161,9 @@ Pass occur{ var, env }; maybe_accept( ty, occur ); - return occur.pass.result; - } -} - -bool TypeEnvironment::combine( + return occur.core.result; + } +} + +bool TypeEnvironment::combine( const TypeEnvironment & o, OpenVarSet & open, const SymbolTable & symtab ) { // short-circuit easy cases @@ -199,5 +199,5 @@ auto st = internal_lookup( *vt ); if ( st == env.end() ) { - // unbound, safe to add if occurs + // unbound, safe to add if occurs if ( r.bound && occurs( r.bound, *vt, *this ) ) return false; r.vars.emplace( *vt ); @@ -266,8 +266,8 @@ } -bool TypeEnvironment::bindVar( - const TypeInstType * typeInst, const Type * bindTo, const TypeDecl::Data & data, - AssertionSet & need, AssertionSet & have, const OpenVarSet & open, WidenMode widen, - const SymbolTable & symtab +bool TypeEnvironment::bindVar( + const TypeInstType * typeInst, const Type * bindTo, const TypeDecl::Data & data, + AssertionSet & need, AssertionSet & have, const OpenVarSet & open, WidenMode widen, + const SymbolTable & symtab ) { // remove references from bound type, so that type variables can only bind to value types @@ -286,6 +286,6 @@ ptr newType = it->bound; reset_qualifiers( newType, typeInst->qualifiers ); - if ( unifyInexact( - newType, target, *this, need, have, open, + if ( unifyInexact( + newType, target, *this, need, have, open, widen & WidenMode{ it->allowWidening, true }, symtab, common ) ) { if ( common ) { @@ -300,5 +300,5 @@ } } else { - env.emplace_back( + env.emplace_back( typeInst->name, target, widen.first && widen.second, data ); } @@ -306,12 +306,12 @@ } -bool TypeEnvironment::bindVarToVar( - const TypeInstType * var1, const TypeInstType * var2, TypeDecl::Data && data, - AssertionSet & need, AssertionSet & have, const OpenVarSet & open, - WidenMode widen, const SymbolTable & symtab +bool TypeEnvironment::bindVarToVar( + const TypeInstType * var1, const TypeInstType * var2, TypeDecl::Data && data, + AssertionSet & need, AssertionSet & have, const OpenVarSet & open, + WidenMode widen, const SymbolTable & symtab ) { auto c1 = internal_lookup( var1->name ); auto c2 = internal_lookup( var2->name ); - + // exit early if variables already bound together if ( c1 != env.end() && c1 == c2 ) { @@ -396,5 +396,5 @@ } -bool TypeEnvironment::mergeBound( +bool TypeEnvironment::mergeBound( EqvClass & to, const EqvClass & from, OpenVarSet & open, const SymbolTable & symtab ) { if ( from.bound ) { @@ -406,5 +406,5 @@ AssertionSet need, have; - if ( unifyInexact( + if ( unifyInexact( toType, fromType, *this, need, have, open, widen, symtab, common ) ) { // unifies, set common type if necessary @@ -424,5 +424,5 @@ } -bool TypeEnvironment::mergeClasses( +bool TypeEnvironment::mergeClasses( ClassList::iterator to, ClassList::iterator from, OpenVarSet & open, const SymbolTable & symtab ) { Index: src/AST/TypeEnvironment.hpp =================================================================== --- src/AST/TypeEnvironment.hpp (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/AST/TypeEnvironment.hpp (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -37,20 +37,20 @@ /// Adding this comparison operator significantly improves assertion satisfaction run time for /// some cases. The current satisfaction algorithm's speed partially depends on the order of -/// assertions. Assertions which have fewer possible matches should appear before assertions -/// which have more possible matches. This seems to imply that this could be further improved -/// by providing an indexer as an additional argument and ordering based on the number of +/// assertions. Assertions which have fewer possible matches should appear before assertions +/// which have more possible matches. This seems to imply that this could be further improved +/// by providing an indexer as an additional argument and ordering based on the number of /// matches of the same kind (object, function) for the names of the declarations. /// -/// I've seen a TU go from 54 minutes to 1 minute 34 seconds with the addition of this +/// I've seen a TU go from 54 minutes to 1 minute 34 seconds with the addition of this /// comparator. /// -/// Note: since this compares pointers for position, minor changes in the source file that -/// affect memory layout can alter compilation time in unpredictable ways. For example, the -/// placement of a line directive can reorder type pointers with respect to each other so that -/// assertions are seen in different orders, causing a potentially different number of -/// unification calls when resolving assertions. I've seen a TU go from 36 seconds to 27 -/// seconds by reordering line directives alone, so it would be nice to fix this comparison so -/// that assertions compare more consistently. I've tried to modify this to compare on mangle -/// name instead of type as the second comparator, but this causes some assertions to never be +/// Note: since this compares pointers for position, minor changes in the source file that +/// affect memory layout can alter compilation time in unpredictable ways. For example, the +/// placement of a line directive can reorder type pointers with respect to each other so that +/// assertions are seen in different orders, causing a potentially different number of +/// unification calls when resolving assertions. I've seen a TU go from 36 seconds to 27 +/// seconds by reordering line directives alone, so it would be nice to fix this comparison so +/// that assertions compare more consistently. I've tried to modify this to compare on mangle +/// name instead of type as the second comparator, but this causes some assertions to never be /// recorded. More investigation is needed. struct AssertCompare { @@ -86,5 +86,5 @@ void print( std::ostream &, const OpenVarSet &, Indenter indent = {} ); -/// Represents an equivalence class of bound type variables, optionally with the concrete type +/// Represents an equivalence class of bound type variables, optionally with the concrete type /// they bind to. struct EqvClass { @@ -95,7 +95,7 @@ EqvClass() : vars(), bound(), allowWidening( true ), data() {} - + /// Copy-with-bound constructor - EqvClass( const EqvClass & o, const Type * b ) + EqvClass( const EqvClass & o, const Type * b ) : vars( o.vars ), bound( b ), allowWidening( o.allowWidening ), data( o.data ) {} @@ -142,16 +142,16 @@ void writeToSubstitution( TypeSubstitution & sub ) const; - template< typename node_t, enum Node::ref_type ref_t > - int apply( ptr_base< node_t, ref_t > & type ) const { + template< typename node_t > + auto apply( node_t && type ) const { TypeSubstitution sub; writeToSubstitution( sub ); - return sub.apply( type ); - } - - template< typename node_t, enum Node::ref_type ref_t > - int applyFree( ptr_base< node_t, ref_t > & type ) const { + return sub.apply( std::forward(type) ); + } + + template< typename node_t > + auto applyFree( node_t && type ) const { TypeSubstitution sub; writeToSubstitution( sub ); - return sub.applyFree( type ); + return sub.applyFree( std::forward(type) ); } @@ -172,16 +172,16 @@ void addActual( const TypeEnvironment & actualEnv, OpenVarSet & openVars ); - /// Binds the type class represented by `typeInst` to the type `bindTo`; will add the class if + /// Binds the type class represented by `typeInst` to the type `bindTo`; will add the class if /// needed. Returns false on failure. - bool bindVar( - const TypeInstType * typeInst, const Type * bindTo, const TypeDecl::Data & data, - AssertionSet & need, AssertionSet & have, const OpenVarSet & openVars, + bool bindVar( + const TypeInstType * typeInst, const Type * bindTo, const TypeDecl::Data & data, + AssertionSet & need, AssertionSet & have, const OpenVarSet & openVars, ResolvExpr::WidenMode widen, const SymbolTable & symtab ); - - /// Binds the type classes represented by `var1` and `var2` together; will add one or both + + /// Binds the type classes represented by `var1` and `var2` together; will add one or both /// classes if needed. Returns false on failure. - bool bindVarToVar( - const TypeInstType * var1, const TypeInstType * var2, TypeDecl::Data && data, - AssertionSet & need, AssertionSet & have, const OpenVarSet & openVars, + bool bindVarToVar( + const TypeInstType * var1, const TypeInstType * var2, TypeDecl::Data && data, + AssertionSet & need, AssertionSet & have, const OpenVarSet & openVars, ResolvExpr::WidenMode widen, const SymbolTable & symtab ); @@ -198,10 +198,10 @@ /// Unifies the type bound of `to` with the type bound of `from`, returning false if fails - bool mergeBound( + bool mergeBound( EqvClass & to, const EqvClass & from, OpenVarSet & openVars, const SymbolTable & symtab ); /// Merges two type classes from local environment, returning false if fails - bool mergeClasses( - ClassList::iterator to, ClassList::iterator from, OpenVarSet & openVars, + bool mergeClasses( + ClassList::iterator to, ClassList::iterator from, OpenVarSet & openVars, const SymbolTable & symtab ); Index: src/AST/TypeSubstitution.cpp =================================================================== --- src/AST/TypeSubstitution.cpp (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/AST/TypeSubstitution.cpp (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -18,4 +18,7 @@ namespace ast { + + +// size_t TypeSubstitution::Substituter::traceId = Stats::Heap::new_stacktrace_id("TypeSubstitution"); TypeSubstitution::TypeSubstitution() { @@ -92,5 +95,5 @@ namespace { struct EnvTrimmer { - ptr env; + const TypeSubstitution * env; TypeSubstitution * newEnv; EnvTrimmer( const TypeSubstitution * env, TypeSubstitution * newEnv ) : env( env ), newEnv( newEnv ){} @@ -108,11 +111,6 @@ if ( env ) { TypeSubstitution * newEnv = new TypeSubstitution(); -#if TIME_TO_CONVERT_PASSES Pass trimmer( env, newEnv ); expr->accept( trimmer ); -#else - (void)expr; - (void)env; -#endif return newEnv; } @@ -121,19 +119,15 @@ void TypeSubstitution::normalize() { -#if TIME_TO_CONVERT_PASSES - PassVisitor sub( *this, true ); + Pass sub( *this, true ); do { - sub.pass.subCount = 0; - sub.pass.freeOnly = true; + sub.core.subCount = 0; + sub.core.freeOnly = true; for ( TypeEnvType::iterator i = typeEnv.begin(); i != typeEnv.end(); ++i ) { - i->second = i->second->acceptMutator( sub ); - } - } while ( sub.pass.subCount ); -#endif -} - -#if TIME_TO_CONVERT_PASSES - -Type * TypeSubstitution::Substituter::postmutate( TypeInstType *inst ) { + i->second = i->second->accept( sub ); + } + } while ( sub.core.subCount ); +} + +const Type * TypeSubstitution::Substituter::postvisit( const TypeInstType *inst ) { BoundVarsType::const_iterator bound = boundVars.find( inst->name ); if ( bound != boundVars.end() ) return inst; @@ -146,5 +140,5 @@ // Note: this does not prevent cycles in the general case, so it may be necessary to do something more sophisticated here. // TODO: investigate preventing type variables from being bound to themselves in the first place. - if ( TypeInstType * replacement = i->second.as() ) { + if ( const TypeInstType * replacement = i->second.as() ) { if ( inst->name == replacement->name ) { return inst; @@ -153,13 +147,14 @@ // std::cerr << "found " << inst->name << ", replacing with " << i->second << std::endl; subCount++; - Type * newtype = i->second->clone(); - newtype->get_qualifiers() |= inst->get_qualifiers(); - delete inst; - // Note: need to recursively apply substitution to the new type because normalize does not substitute bound vars, but bound vars must be substituted when not in freeOnly mode. - return newtype->acceptMutator( *visitor ); - } // if -} - -Expression * TypeSubstitution::Substituter::postmutate( NameExpr * nameExpr ) { + ptr newType = i->second; // force clone if needed + add_qualifiers( newType, inst->qualifiers ); + // Note: need to recursively apply substitution to the new type because normalize does not + // substitute bound vars, but bound vars must be substituted when not in freeOnly mode. + newType = newType->accept( *visitor ); + return newType.release(); + } // if +} + +const Expr * TypeSubstitution::Substituter::postvisit( const NameExpr * nameExpr ) { VarEnvType::const_iterator i = sub.varEnv.find( nameExpr->name ); if ( i == sub.varEnv.end() ) { @@ -167,46 +162,43 @@ } else { subCount++; - delete nameExpr; - return i->second->clone(); - } // if -} - -void TypeSubstitution::Substituter::premutate( Type * type ) { + return i->second; + } // if +} + +void TypeSubstitution::Substituter::previsit( const ParameterizedType * ptype ) { GuardValue( boundVars ); // bind type variables from forall-qualifiers if ( freeOnly ) { - for ( Type::ForallList::const_iterator tyvar = type->forall.begin(); tyvar != type->forall.end(); ++tyvar ) { - boundVars.insert( (*tyvar)->name ); + for ( const TypeDecl * tyvar : ptype->forall ) { + boundVars.insert( tyvar->name ); } // for } // if } -template< typename TypeClass > -void TypeSubstitution::Substituter::handleAggregateType( TypeClass * type ) { +void TypeSubstitution::Substituter::handleAggregateType( const ReferenceToType * type ) { GuardValue( boundVars ); // bind type variables from forall-qualifiers if ( freeOnly ) { - for ( Type::ForallList::const_iterator tyvar = type->forall.begin(); tyvar != type->forall.end(); ++tyvar ) { - boundVars.insert( (*tyvar)->name ); + for ( const TypeDecl * tyvar : type->forall ) { + boundVars.insert( tyvar->name ); } // for // bind type variables from generic type instantiations - std::list< TypeDecl* > *baseParameters = type->get_baseParameters(); - if ( baseParameters && ! type->parameters.empty() ) { - for ( std::list< TypeDecl* >::const_iterator tyvar = baseParameters->begin(); tyvar != baseParameters->end(); ++tyvar ) { - boundVars.insert( (*tyvar)->name ); - } // for - } // if - } // if -} - -void TypeSubstitution::Substituter::premutate( StructInstType * aggregateUseType ) { + if ( auto decl = type->aggr() ) { + if ( ! type->params.empty() ) { + for ( const TypeDecl * tyvar : decl->params ) { + boundVars.insert( tyvar->name ); + } // for + } // if + } + } // if +} + +void TypeSubstitution::Substituter::previsit( const StructInstType * aggregateUseType ) { handleAggregateType( aggregateUseType ); } -void TypeSubstitution::Substituter::premutate( UnionInstType *aggregateUseType ) { +void TypeSubstitution::Substituter::previsit( const UnionInstType *aggregateUseType ) { handleAggregateType( aggregateUseType ); } - -#endif } // namespace ast Index: src/AST/TypeSubstitution.hpp =================================================================== --- src/AST/TypeSubstitution.hpp (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/AST/TypeSubstitution.hpp (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -44,13 +44,20 @@ TypeSubstitution &operator=( const TypeSubstitution &other ); - template< typename SynTreeClass > int apply( const SynTreeClass *& input ) const; - template< typename SynTreeClass > int applyFree( const SynTreeClass *& input ) const; + template< typename SynTreeClass > + struct ApplyResult { + // const SynTreeClass * node; + ast::ptr node; + int count; + }; + + template< typename SynTreeClass > ApplyResult apply( const SynTreeClass * input ) const; + template< typename SynTreeClass > ApplyResult applyFree( const SynTreeClass * input ) const; template< typename node_t, enum Node::ref_type ref_t > int apply( ptr_base< node_t, ref_t > & input ) const { const node_t * p = input.get(); - int ret = apply(p); - input = p; - return ret; + auto ret = apply(p); + input = ret.node; + return ret.count; } @@ -58,7 +65,7 @@ int applyFree( ptr_base< node_t, ref_t > & input ) const { const node_t * p = input.get(); - int ret = applyFree(p); - input = p; - return ret; + auto ret = applyFree(p); + input = ret.node; + return ret.count; } @@ -92,5 +99,5 @@ void initialize( const TypeSubstitution &src, TypeSubstitution &dest ); - template + template friend class Pass; @@ -147,4 +154,5 @@ // PassVisitor are defined before PassVisitor implementation accesses TypeSubstitution internals. #include "Pass.hpp" +#include "Copy.hpp" namespace ast { @@ -152,21 +160,18 @@ // definitition must happen after PassVisitor is included so that WithGuards can be used struct TypeSubstitution::Substituter : public WithGuards, public WithVisitorRef { + static size_t traceId; Substituter( const TypeSubstitution & sub, bool freeOnly ) : sub( sub ), freeOnly( freeOnly ) {} -#if TIME_TO_CONVERT_PASSES - - Type * postmutate( TypeInstType * aggregateUseType ); - Expression * postmutate( NameExpr * nameExpr ); + const Type * postvisit( const TypeInstType * aggregateUseType ); + const Expr * postvisit( const NameExpr * nameExpr ); /// Records type variable bindings from forall-statements - void premutate( Type * type ); + void previsit( const ParameterizedType * type ); /// Records type variable bindings from forall-statements and instantiations of generic types - template< typename TypeClass > void handleAggregateType( TypeClass * type ); - - void premutate( StructInstType * aggregateUseType ); - void premutate( UnionInstType * aggregateUseType ); - -#endif + void handleAggregateType( const ReferenceToType * type ); + + void previsit( const StructInstType * aggregateUseType ); + void previsit( const UnionInstType * aggregateUseType ); const TypeSubstitution & sub; @@ -179,23 +184,17 @@ template< typename SynTreeClass > -int TypeSubstitution::apply( const SynTreeClass *& input ) const { +TypeSubstitution::ApplyResult TypeSubstitution::apply( const SynTreeClass * input ) const { assert( input ); Pass sub( *this, false ); - input = strict_dynamic_cast< const SynTreeClass * >( input->accept( sub ) ); -/// std::cerr << "substitution result is: "; -/// newType->print( std::cerr ); -/// std::cerr << std::endl; - return sub.pass.subCount; + input = strict_dynamic_cast< const SynTreeClass * >( deepCopy(input)->accept( sub ) ); + return { input, sub.core.subCount }; } template< typename SynTreeClass > -int TypeSubstitution::applyFree( const SynTreeClass *& input ) const { +TypeSubstitution::ApplyResult TypeSubstitution::applyFree( const SynTreeClass * input ) const { assert( input ); Pass sub( *this, true ); input = strict_dynamic_cast< const SynTreeClass * >( input->accept( sub ) ); -/// std::cerr << "substitution result is: "; -/// newType->print( std::cerr ); -/// std::cerr << std::endl; - return sub.pass.subCount; + return { input, sub.core.subCount }; } Index: src/AST/module.mk =================================================================== --- src/AST/module.mk (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/AST/module.mk (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -22,4 +22,5 @@ AST/DeclReplacer.cpp \ AST/Expr.cpp \ + AST/ForallSubstitutionTable.cpp \ AST/GenericSubstitution.cpp \ AST/Init.cpp \ Index: src/AST/porting.md =================================================================== --- src/AST/porting.md (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/AST/porting.md (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -47,4 +47,9 @@ template friend node_t * mutate(const node_t * node); + template + friend node_t * shallowCopy(const node_t * node); + or equilant. +* You should use the `mutate` function where possible as it avoids extra copies. + * If you must copy use `shallowCopy` or `deepCopy` as required. All leaves of the `Node` inheritance tree are now declared `final` Index: src/Common/Eval.cc =================================================================== --- src/Common/Eval.cc (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/Common/Eval.cc (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -168,5 +168,5 @@ if (expr) { expr->accept(ev); - return std::make_pair(ev.pass.value, ev.pass.valid); + return std::make_pair(ev.core.value, ev.core.valid); } else { return std::make_pair(0, false); Index: src/Common/ScopedMap.h =================================================================== --- src/Common/ScopedMap.h (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/Common/ScopedMap.h (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -249,4 +249,6 @@ /// Gets the note at the given scope + Note& getNote() { return scopes.back().note; } + const Note& getNote() const { return scopes.back().note; } Note& getNote( size_type i ) { return scopes[i].note; } const Note& getNote( size_type i ) const { return scopes[i].note; } Index: src/Common/Stats/Heap.cc =================================================================== --- src/Common/Stats/Heap.cc (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/Common/Stats/Heap.cc (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -53,4 +53,28 @@ const size_t passes_size = sizeof(passes) / sizeof(passes[0]); size_t passes_cnt = 1; + + StatBlock stacktrace_stats[100]; + size_t stacktrace_stats_count = 0; + bool stacktrace_stats_enabled = true; + + size_t trace[1000]; + const size_t stacktrace_max_depth = sizeof(trace) / sizeof(size_t); + size_t stacktrace_depth; + + size_t new_stacktrace_id(const char * const name) { + stacktrace_stats[stacktrace_stats_count].name = name; + return stacktrace_stats_count++; + } + + void stacktrace_push(size_t id) { + ++stacktrace_depth; + assertf(stacktrace_depth < stacktrace_max_depth, "Stack trace too deep: increase size of array in Heap.cc"); + trace[stacktrace_depth] = id; + } + + void stacktrace_pop() { + assertf(stacktrace_depth > 0, "Invalid stack tracing operation: trace is empty"); + --stacktrace_depth; + } void newPass( const char * const name ) { @@ -116,4 +140,13 @@ for(size_t i = 0; i < passes_cnt; i++) { print(passes[i], nc, total_mallocs, total_frees, overall_peak); + } + + print('-', nct); + std::cerr << std::setw(nc) << "Trace"; + std::cerr << " | Malloc Count | Free Count | Peak Allocs |" << std::endl; + + print('-', nct); + for (size_t i = 0; i < stacktrace_stats_count; i++) { + print(stacktrace_stats[i], nc, total_mallocs, total_frees, overall_peak); } print('-', nct); @@ -188,4 +221,8 @@ = std::max(passes[passes_cnt - 1].peak_allocs, passes[passes_cnt - 1].n_allocs); } + + if ( stacktrace_stats_enabled && stacktrace_depth > 0) { + stacktrace_stats[trace[stacktrace_depth]].mallocs++; + } return __malloc( size ); } @@ -196,4 +233,7 @@ passes[passes_cnt - 1].frees++; passes[passes_cnt - 1].n_allocs--; + } + if ( stacktrace_stats_enabled && stacktrace_depth > 0) { + stacktrace_stats[trace[stacktrace_depth]].frees++; } return __free( ptr ); @@ -208,4 +248,7 @@ = std::max(passes[passes_cnt - 1].peak_allocs, passes[passes_cnt - 1].n_allocs); } + if ( stacktrace_stats_enabled && stacktrace_depth > 0) { + stacktrace_stats[trace[stacktrace_depth]].mallocs++; + } return __calloc( nelem, size ); } @@ -218,4 +261,8 @@ passes[passes_cnt - 1].frees++; } // if + if ( stacktrace_stats_enabled && stacktrace_depth > 0) { + stacktrace_stats[trace[stacktrace_depth]].mallocs++; + stacktrace_stats[trace[stacktrace_depth]].frees++; + } return s; } Index: src/Common/Stats/Heap.h =================================================================== --- src/Common/Stats/Heap.h (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/Common/Stats/Heap.h (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -20,4 +20,8 @@ void newPass( const char * const name ); void print(); + + size_t new_stacktrace_id(const char * const name); + void stacktrace_push(size_t id); + void stacktrace_pop(); } } Index: src/CompilationState.cc =================================================================== --- src/CompilationState.cc (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/CompilationState.cc (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -14,4 +14,6 @@ // +#include "config.h" + int astp = false, @@ -28,4 +30,5 @@ genproto = false, deterministic_output = false, + useNewAST = CFA_USE_NEW_AST, nomainp = false, parsep = false, Index: src/CompilationState.h =================================================================== --- src/CompilationState.h (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/CompilationState.h (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -29,4 +29,5 @@ genproto, deterministic_output, + useNewAST, nomainp, parsep, Index: src/InitTweak/InitTweak.cc =================================================================== --- src/InitTweak/InitTweak.cc (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/InitTweak/InitTweak.cc (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -127,5 +127,5 @@ ast::Pass< InitFlattener_new > flattener; maybe_accept( init, flattener ); - return std::move( flattener.pass.argList ); + return std::move( flattener.core.argList ); } @@ -561,5 +561,5 @@ ast::Pass< CallFinder_new > finder{ std::vector< std::string >{ "?{}", "^?{}" } }; maybe_accept( stmt, finder ); - return std::move( finder.pass.matches ); + return std::move( finder.core.matches ); } Index: src/ResolvExpr/AdjustExprType.cc =================================================================== --- src/ResolvExpr/AdjustExprType.cc (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/ResolvExpr/AdjustExprType.cc (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -100,35 +100,36 @@ namespace { - struct AdjustExprType_new final : public ast::WithShortCircuiting { + class AdjustExprType_new final : public ast::WithShortCircuiting { + const ast::SymbolTable & symtab; + public: const ast::TypeEnvironment & tenv; - const ast::SymbolTable & symtab; AdjustExprType_new( const ast::TypeEnvironment & e, const ast::SymbolTable & syms ) - : tenv( e ), symtab( syms ) {} + : symtab( syms ), tenv( e ) {} - void premutate( const ast::VoidType * ) { visit_children = false; } - void premutate( const ast::BasicType * ) { visit_children = false; } - void premutate( const ast::PointerType * ) { visit_children = false; } - void premutate( const ast::ArrayType * ) { visit_children = false; } - void premutate( const ast::FunctionType * ) { visit_children = false; } - void premutate( const ast::StructInstType * ) { visit_children = false; } - void premutate( const ast::UnionInstType * ) { visit_children = false; } - void premutate( const ast::EnumInstType * ) { visit_children = false; } - void premutate( const ast::TraitInstType * ) { visit_children = false; } - void premutate( const ast::TypeInstType * ) { visit_children = false; } - void premutate( const ast::TupleType * ) { visit_children = false; } - void premutate( const ast::VarArgsType * ) { visit_children = false; } - void premutate( const ast::ZeroType * ) { visit_children = false; } - void premutate( const ast::OneType * ) { visit_children = false; } + void previsit( const ast::VoidType * ) { visit_children = false; } + void previsit( const ast::BasicType * ) { visit_children = false; } + void previsit( const ast::PointerType * ) { visit_children = false; } + void previsit( const ast::ArrayType * ) { visit_children = false; } + void previsit( const ast::FunctionType * ) { visit_children = false; } + void previsit( const ast::StructInstType * ) { visit_children = false; } + void previsit( const ast::UnionInstType * ) { visit_children = false; } + void previsit( const ast::EnumInstType * ) { visit_children = false; } + void previsit( const ast::TraitInstType * ) { visit_children = false; } + void previsit( const ast::TypeInstType * ) { visit_children = false; } + void previsit( const ast::TupleType * ) { visit_children = false; } + void previsit( const ast::VarArgsType * ) { visit_children = false; } + void previsit( const ast::ZeroType * ) { visit_children = false; } + void previsit( const ast::OneType * ) { visit_children = false; } - const ast::Type * postmutate( const ast::ArrayType * at ) { + const ast::Type * postvisit( const ast::ArrayType * at ) { return new ast::PointerType{ at->base, at->qualifiers }; } - const ast::Type * postmutate( const ast::FunctionType * ft ) { + const ast::Type * postvisit( const ast::FunctionType * ft ) { return new ast::PointerType{ ft }; } - const ast::Type * postmutate( const ast::TypeInstType * inst ) { + const ast::Type * postvisit( const ast::TypeInstType * inst ) { // replace known function-type-variables with pointer-to-function if ( const ast::EqvClass * eqvClass = tenv.lookup( inst->name ) ) { Index: src/ResolvExpr/Candidate.hpp =================================================================== --- src/ResolvExpr/Candidate.hpp (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/ResolvExpr/Candidate.hpp (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -51,14 +51,20 @@ Candidate( const ast::Expr * x, const ast::TypeEnvironment & e ) - : expr( x ), cost( Cost::zero ), cvtCost( Cost::zero ), env( e ), open(), need() {} + : expr( x ), cost( Cost::zero ), cvtCost( Cost::zero ), env( e ), open(), need() { + assert(x->result); + } Candidate( const Candidate & o, const ast::Expr * x, const Cost & addedCost = Cost::zero ) : expr( x ), cost( o.cost + addedCost ), cvtCost( Cost::zero ), env( o.env ), open( o.open ), - need( o.need ) {} + need( o.need ) { + assert(x->result); + } Candidate( - const ast::Expr * x, const ast::TypeEnvironment & e, const ast::OpenVarSet & o, + const ast::Expr * x, const ast::TypeEnvironment & e, const ast::OpenVarSet & o, const ast::AssertionSet & n, const Cost & c, const Cost & cvt = Cost::zero ) - : expr( x ), cost( c ), cvtCost( cvt ), env( e ), open( o ), need( n.begin(), n.end() ) {} + : expr( x ), cost( c ), cvtCost( cvt ), env( e ), open( o ), need( n.begin(), n.end() ) { + assert(x->result); + } Candidate( @@ -66,5 +72,7 @@ ast::AssertionSet && n, const Cost & c, const Cost & cvt = Cost::zero ) : expr( x ), cost( c ), cvtCost( cvt ), env( std::move( e ) ), open( std::move( o ) ), - need( n.begin(), n.end() ) {} + need( n.begin(), n.end() ) { + assert(x->result); + } }; Index: src/ResolvExpr/CandidateFinder.cpp =================================================================== --- src/ResolvExpr/CandidateFinder.cpp (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/ResolvExpr/CandidateFinder.cpp (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -9,7 +9,7 @@ // Author : Aaron B. Moss // Created On : Wed Jun 5 14:30:00 2019 -// Last Modified By : Aaron B. Moss -// Last Modified On : Wed Jun 5 14:30:00 2019 -// Update Count : 1 +// Last Modified By : Andrew Beach +// Last Modified On : Tue Oct 1 14:55:00 2019 +// Update Count : 2 // @@ -54,5 +54,5 @@ return new ast::CastExpr{ expr, expr->result->stripReferences() }; } - + return expr; } @@ -61,7 +61,7 @@ UniqueId globalResnSlot = 0; -Cost computeConversionCost( - const ast::Type * argType, const ast::Type * paramType, const ast::SymbolTable & symtab, - const ast::TypeEnvironment & env +Cost computeConversionCost( + const ast::Type * argType, const ast::Type * paramType, bool argIsLvalue, + const ast::SymbolTable & symtab, const ast::TypeEnvironment & env ) { PRINT( @@ -74,5 +74,5 @@ std::cerr << std::endl; ) - Cost convCost = conversionCost( argType, paramType, symtab, env ); + Cost convCost = conversionCost( argType, paramType, argIsLvalue, symtab, env ); PRINT( std::cerr << std::endl << "cost is " << convCost << std::endl; @@ -107,12 +107,13 @@ /// Computes conversion cost for a given expression to a given type - const ast::Expr * computeExpressionConversionCost( - const ast::Expr * arg, const ast::Type * paramType, const ast::SymbolTable & symtab, const ast::TypeEnvironment & env, Cost & outCost + const ast::Expr * computeExpressionConversionCost( + const ast::Expr * arg, const ast::Type * paramType, const ast::SymbolTable & symtab, const ast::TypeEnvironment & env, Cost & outCost ) { - Cost convCost = computeConversionCost( arg->result, paramType, symtab, env ); + Cost convCost = computeConversionCost( + arg->result, paramType, arg->get_lvalue(), symtab, env ); outCost += convCost; - // If there is a non-zero conversion cost, ignoring poly cost, then the expression requires - // conversion. Ignore poly cost for now, since this requires resolution of the cast to + // If there is a non-zero conversion cost, ignoring poly cost, then the expression requires + // conversion. Ignore poly cost for now, since this requires resolution of the cast to // infer parameters and this does not currently work for the reason stated below Cost tmpCost = convCost; @@ -123,16 +124,16 @@ return new ast::CastExpr{ arg, newType }; - // xxx - *should* be able to resolve this cast, but at the moment pointers are not - // castable to zero_t, but are implicitly convertible. This is clearly inconsistent, + // xxx - *should* be able to resolve this cast, but at the moment pointers are not + // castable to zero_t, but are implicitly convertible. This is clearly inconsistent, // once this is fixed it should be possible to resolve the cast. - // xxx - this isn't working, it appears because type1 (parameter) is seen as widenable, - // but it shouldn't be because this makes the conversion from DT* to DT* since + // xxx - this isn't working, it appears because type1 (parameter) is seen as widenable, + // but it shouldn't be because this makes the conversion from DT* to DT* since // commontype(zero_t, DT*) is DT*, rather than nothing // CandidateFinder finder{ symtab, env }; // finder.find( arg, ResolvMode::withAdjustment() ); - // assertf( finder.candidates.size() > 0, + // assertf( finder.candidates.size() > 0, // "Somehow castable expression failed to find alternatives." ); - // assertf( finder.candidates.size() == 1, + // assertf( finder.candidates.size() == 1, // "Somehow got multiple alternatives for known cast expression." ); // return finder.candidates.front()->expr; @@ -143,6 +144,6 @@ /// Computes conversion cost for a given candidate - Cost computeApplicationConversionCost( - CandidateRef cand, const ast::SymbolTable & symtab + Cost computeApplicationConversionCost( + CandidateRef cand, const ast::SymbolTable & symtab ) { auto appExpr = cand->expr.strict_as< ast::ApplicationExpr >(); @@ -167,9 +168,9 @@ if ( function->isVarArgs ) { convCost.incUnsafe(); - PRINT( std::cerr << "end of params with varargs function: inc unsafe: " + PRINT( std::cerr << "end of params with varargs function: inc unsafe: " << convCost << std::endl; ; ) // convert reference-typed expressions into value-typed expressions - cand->expr = ast::mutate_field_index( - appExpr, &ast::ApplicationExpr::args, i, + cand->expr = ast::mutate_field_index( + appExpr, &ast::ApplicationExpr::args, i, referenceToRvalueConversion( args[i], convCost ) ); continue; @@ -180,5 +181,5 @@ // Default arguments should be free - don't include conversion cost. // Unwrap them here because they are not relevant to the rest of the system - cand->expr = ast::mutate_field_index( + cand->expr = ast::mutate_field_index( appExpr, &ast::ApplicationExpr::args, i, def->expr ); ++param; @@ -188,7 +189,7 @@ // mark conversion cost and also specialization cost of param type const ast::Type * paramType = (*param)->get_type(); - cand->expr = ast::mutate_field_index( - appExpr, &ast::ApplicationExpr::args, i, - computeExpressionConversionCost( + cand->expr = ast::mutate_field_index( + appExpr, &ast::ApplicationExpr::args, i, + computeExpressionConversionCost( args[i], paramType, symtab, cand->env, convCost ) ); convCost.decSpec( specCost( paramType ) ); @@ -198,5 +199,5 @@ if ( param != params.end() ) return Cost::infinity; - // specialization cost of return types can't be accounted for directly, it disables + // specialization cost of return types can't be accounted for directly, it disables // otherwise-identical calls, like this example based on auto-newline in the I/O lib: // @@ -215,7 +216,7 @@ } - void makeUnifiableVars( - const ast::ParameterizedType * type, ast::OpenVarSet & unifiableVars, - ast::AssertionSet & need + void makeUnifiableVars( + const ast::ParameterizedType * type, ast::OpenVarSet & unifiableVars, + ast::AssertionSet & need ) { for ( const ast::TypeDecl * tyvar : type->forall ) { @@ -254,29 +255,29 @@ ArgPack() - : parent( 0 ), expr(), cost( Cost::zero ), env(), need(), have(), open(), nextArg( 0 ), + : parent( 0 ), expr(), cost( Cost::zero ), env(), need(), have(), open(), nextArg( 0 ), tupleStart( 0 ), nextExpl( 0 ), explAlt( 0 ) {} - - ArgPack( - const ast::TypeEnvironment & env, const ast::AssertionSet & need, + + ArgPack( + const ast::TypeEnvironment & env, const ast::AssertionSet & need, const ast::AssertionSet & have, const ast::OpenVarSet & open ) - : parent( 0 ), expr(), cost( Cost::zero ), env( env ), need( need ), have( have ), + : parent( 0 ), expr(), cost( Cost::zero ), env( env ), need( need ), have( have ), open( open ), nextArg( 0 ), tupleStart( 0 ), nextExpl( 0 ), explAlt( 0 ) {} - + ArgPack( - std::size_t parent, const ast::Expr * expr, ast::TypeEnvironment && env, - ast::AssertionSet && need, ast::AssertionSet && have, ast::OpenVarSet && open, - unsigned nextArg, unsigned tupleStart = 0, Cost cost = Cost::zero, + std::size_t parent, const ast::Expr * expr, ast::TypeEnvironment && env, + ast::AssertionSet && need, ast::AssertionSet && have, ast::OpenVarSet && open, + unsigned nextArg, unsigned tupleStart = 0, Cost cost = Cost::zero, unsigned nextExpl = 0, unsigned explAlt = 0 ) : parent(parent), expr( expr ), cost( cost ), env( move( env ) ), need( move( need ) ), have( move( have ) ), open( move( open ) ), nextArg( nextArg ), tupleStart( tupleStart ), nextExpl( nextExpl ), explAlt( explAlt ) {} - + ArgPack( - const ArgPack & o, ast::TypeEnvironment && env, ast::AssertionSet && need, + const ArgPack & o, ast::TypeEnvironment && env, ast::AssertionSet && need, ast::AssertionSet && have, ast::OpenVarSet && open, unsigned nextArg, Cost added ) - : parent( o.parent ), expr( o.expr ), cost( o.cost + added ), env( move( env ) ), - need( move( need ) ), have( move( have ) ), open( move( open ) ), nextArg( nextArg ), + : parent( o.parent ), expr( o.expr ), cost( o.cost + added ), env( move( env ) ), + need( move( need ) ), have( move( have ) ), open( move( open ) ), nextArg( nextArg ), tupleStart( o.tupleStart ), nextExpl( 0 ), explAlt( 0 ) {} - + /// true if this pack is in the middle of an exploded argument bool hasExpl() const { return nextExpl > 0; } @@ -286,5 +287,5 @@ return args[ nextArg-1 ][ explAlt ]; } - + /// Ends a tuple expression, consolidating the appropriate args void endTuple( const std::vector< ArgPack > & packs ) { @@ -307,8 +308,8 @@ /// Instantiates an argument to match a parameter, returns false if no matching results left - bool instantiateArgument( - const ast::Type * paramType, const ast::Init * init, const ExplodedArgs_new & args, - std::vector< ArgPack > & results, std::size_t & genStart, const ast::SymbolTable & symtab, - unsigned nTuples = 0 + bool instantiateArgument( + const ast::Type * paramType, const ast::Init * init, const ExplodedArgs_new & args, + std::vector< ArgPack > & results, std::size_t & genStart, const ast::SymbolTable & symtab, + unsigned nTuples = 0 ) { if ( auto tupleType = dynamic_cast< const ast::TupleType * >( paramType ) ) { @@ -318,5 +319,5 @@ // xxx - dropping initializer changes behaviour from previous, but seems correct // ^^^ need to handle the case where a tuple has a default argument - if ( ! instantiateArgument( + if ( ! instantiateArgument( type, nullptr, args, results, genStart, symtab, nTuples ) ) return false; nTuples = 0; @@ -329,5 +330,5 @@ } else if ( const ast::TypeInstType * ttype = Tuples::isTtype( paramType ) ) { // paramType is a ttype, consumes all remaining arguments - + // completed tuples; will be spliced to end of results to finish std::vector< ArgPack > finalResults{}; @@ -342,5 +343,5 @@ for ( std::size_t i = genStart; i < genEnd; ++i ) { unsigned nextArg = results[i].nextArg; - + // use next element of exploded tuple if present if ( results[i].hasExpl() ) { @@ -352,5 +353,5 @@ results.emplace_back( i, expl.exprs[ results[i].nextExpl ], copy( results[i].env ), - copy( results[i].need ), copy( results[i].have ), + copy( results[i].need ), copy( results[i].have ), copy( results[i].open ), nextArg, nTuples, Cost::zero, nextExpl, results[i].explAlt ); @@ -370,7 +371,5 @@ // push empty tuple expression newResult.parent = i; - std::vector< ast::ptr< ast::Expr > > emptyList; - newResult.expr = - new ast::TupleExpr{ CodeLocation{}, move( emptyList ) }; + newResult.expr = new ast::TupleExpr{ CodeLocation{}, {} }; argType = newResult.expr->result; } else { @@ -400,8 +399,8 @@ // check unification for ttype before adding to final - if ( - unify( + if ( + unify( ttype, argType, newResult.env, newResult.need, newResult.have, - newResult.open, symtab ) + newResult.open, symtab ) ) { finalResults.emplace_back( move( newResult ) ); @@ -424,7 +423,7 @@ if ( expl.exprs.empty() ) { results.emplace_back( - results[i], move( env ), copy( results[i].need ), + results[i], move( env ), copy( results[i].need ), copy( results[i].have ), move( open ), nextArg + 1, expl.cost ); - + continue; } @@ -432,6 +431,6 @@ // add new result results.emplace_back( - i, expl.exprs.front(), move( env ), copy( results[i].need ), - copy( results[i].have ), move( open ), nextArg + 1, nTuples, + i, expl.exprs.front(), move( env ), copy( results[i].need ), + copy( results[i].have ), move( open ), nextArg + 1, nTuples, expl.cost, expl.exprs.size() == 1 ? 0 : 1, j ); } @@ -479,5 +478,5 @@ results.emplace_back( - i, expr, move( env ), move( need ), move( have ), move( open ), nextArg, + i, expr, move( env ), move( need ), move( have ), move( open ), nextArg, nTuples, Cost::zero, nextExpl, results[i].explAlt ); } @@ -495,5 +494,5 @@ if ( unify( paramType, cnst->result, env, need, have, open, symtab ) ) { results.emplace_back( - i, new ast::DefaultArgExpr{ cnst->location, cnst }, move( env ), + i, new ast::DefaultArgExpr{ cnst->location, cnst }, move( env ), move( need ), move( have ), move( open ), nextArg, nTuples ); } @@ -517,7 +516,7 @@ if ( expl.exprs.empty() ) { results.emplace_back( - results[i], move( env ), move( need ), move( have ), move( open ), + results[i], move( env ), move( need ), move( have ), move( open ), nextArg + 1, expl.cost ); - + continue; } @@ -539,5 +538,5 @@ // add new result results.emplace_back( - i, expr, move( env ), move( need ), move( have ), move( open ), + i, expr, move( env ), move( need ), move( have ), move( open ), nextArg + 1, nTuples, expl.cost, expl.exprs.size() == 1 ? 0 : 1, j ); } @@ -548,23 +547,23 @@ genStart = genEnd; - return genEnd != results.size(); + return genEnd != results.size(); // were any new results added? } /// Generate a cast expression from `arg` to `toType` - const ast::Expr * restructureCast( + const ast::Expr * restructureCast( ast::ptr< ast::Expr > & arg, const ast::Type * toType, ast::GeneratedFlag isGenerated = ast::GeneratedCast ) { - if ( - arg->result->size() > 1 - && ! toType->isVoid() - && ! dynamic_cast< const ast::ReferenceType * >( toType ) + if ( + arg->result->size() > 1 + && ! toType->isVoid() + && ! dynamic_cast< const ast::ReferenceType * >( toType ) ) { - // Argument is a tuple and the target type is neither void nor a reference. Cast each - // member of the tuple to its corresponding target type, producing the tuple of those - // cast expressions. If there are more components of the tuple than components in the - // target type, then excess components do not come out in the result expression (but + // Argument is a tuple and the target type is neither void nor a reference. Cast each + // member of the tuple to its corresponding target type, producing the tuple of those + // cast expressions. If there are more components of the tuple than components in the + // target type, then excess components do not come out in the result expression (but // UniqueExpr ensures that the side effects will still be produced) if ( Tuples::maybeImpureIgnoreUnique( arg ) ) { - // expressions which may contain side effects require a single unique instance of + // expressions which may contain side effects require a single unique instance of // the expression arg = new ast::UniqueExpr{ arg->location, arg }; @@ -574,5 +573,5 @@ // cast each component ast::ptr< ast::Expr > idx = new ast::TupleIndexExpr{ arg->location, arg, i }; - components.emplace_back( + components.emplace_back( restructureCast( idx, toType->getComponent( i ), isGenerated ) ); } @@ -594,15 +593,31 @@ /// Actually visits expressions to find their candidate interpretations - struct Finder final : public ast::WithShortCircuiting { + class Finder final : public ast::WithShortCircuiting { + const ast::SymbolTable & symtab; + public: + static size_t traceId; CandidateFinder & selfFinder; - const ast::SymbolTable & symtab; CandidateList & candidates; const ast::TypeEnvironment & tenv; ast::ptr< ast::Type > & targetType; + enum Errors { + NotFound, + NoMatch, + ArgsToFew, + ArgsToMany, + RetsToFew, + RetsToMany, + NoReason + }; + + struct { + Errors code = NotFound; + } reason; + Finder( CandidateFinder & f ) - : selfFinder( f ), symtab( f.symtab ), candidates( f.candidates ), tenv( f.env ), + : symtab( f.localSyms ), selfFinder( f ), candidates( f.candidates ), tenv( f.env ), targetType( f.targetType ) {} - + void previsit( const ast::Node * ) { visit_children = false; } @@ -611,4 +626,5 @@ void addCandidate( Args &&... args ) { candidates.emplace_back( new Candidate{ std::forward( args )... } ); + reason.code = NoReason; } @@ -639,9 +655,9 @@ /// Completes a function candidate with arguments located - void validateFunctionCandidate( - const CandidateRef & func, ArgPack & result, const std::vector< ArgPack > & results, - CandidateList & out + void validateFunctionCandidate( + const CandidateRef & func, ArgPack & result, const std::vector< ArgPack > & results, + CandidateList & out ) { - ast::ApplicationExpr * appExpr = + ast::ApplicationExpr * appExpr = new ast::ApplicationExpr{ func->expr->location, func->expr }; // sum cost and accumulate arguments @@ -657,5 +673,5 @@ appExpr->args = move( vargs ); // build and validate new candidate - auto newCand = + auto newCand = std::make_shared( appExpr, result.env, result.open, result.need, cost ); PRINT( @@ -669,5 +685,5 @@ /// Builds a list of candidates for a function, storing them in out void makeFunctionCandidates( - const CandidateRef & func, const ast::FunctionType * funcType, + const CandidateRef & func, const ast::FunctionType * funcType, const ExplodedArgs_new & args, CandidateList & out ) { @@ -676,6 +692,6 @@ ast::TypeEnvironment funcEnv{ func->env }; makeUnifiableVars( funcType, funcOpen, funcNeed ); - // add all type variables as open variables now so that those not used in the parameter - // list are still considered open + // add all type variables as open variables now so that those not used in the + // parameter list are still considered open funcEnv.add( funcType->forall ); @@ -683,6 +699,6 @@ // attempt to narrow based on expected target type const ast::Type * returnType = funcType->returns.front()->get_type(); - if ( ! unify( - returnType, targetType, funcEnv, funcNeed, funcHave, funcOpen, symtab ) + if ( ! unify( + returnType, targetType, funcEnv, funcNeed, funcHave, funcOpen, symtab ) ) { // unification failed, do not pursue this candidate @@ -698,7 +714,7 @@ for ( const ast::DeclWithType * param : funcType->params ) { auto obj = strict_dynamic_cast< const ast::ObjectDecl * >( param ); - // Try adding the arguments corresponding to the current parameter to the existing + // Try adding the arguments corresponding to the current parameter to the existing // matches - if ( ! instantiateArgument( + if ( ! instantiateArgument( obj->type, obj->init, args, results, genStart, symtab ) ) return; } @@ -750,6 +766,6 @@ if ( expl.exprs.empty() ) { results.emplace_back( - results[i], move( env ), copy( results[i].need ), - copy( results[i].have ), move( open ), nextArg + 1, + results[i], move( env ), copy( results[i].need ), + copy( results[i].have ), move( open ), nextArg + 1, expl.cost ); @@ -760,5 +776,5 @@ results.emplace_back( i, expl.exprs.front(), move( env ), copy( results[i].need ), - copy( results[i].have ), move( open ), nextArg + 1, 0, expl.cost, + copy( results[i].have ), move( open ), nextArg + 1, 0, expl.cost, expl.exprs.size() == 1 ? 0 : 1, j ); } @@ -780,11 +796,11 @@ /// Adds implicit struct-conversions to the alternative list void addAnonConversions( const CandidateRef & cand ) { - // adds anonymous member interpretations whenever an aggregate value type is seen. - // it's okay for the aggregate expression to have reference type -- cast it to the + // adds anonymous member interpretations whenever an aggregate value type is seen. + // it's okay for the aggregate expression to have reference type -- cast it to the // base type to treat the aggregate as the referenced value ast::ptr< ast::Expr > aggrExpr( cand->expr ); ast::ptr< ast::Type > & aggrType = aggrExpr.get_and_mutate()->result; cand->env.apply( aggrType ); - + if ( aggrType.as< ast::ReferenceType >() ) { aggrExpr = new ast::CastExpr{ aggrExpr, aggrType->stripReferences() }; @@ -799,13 +815,13 @@ /// Adds aggregate member interpretations - void addAggMembers( - const ast::ReferenceToType * aggrInst, const ast::Expr * expr, - const Candidate & cand, const Cost & addedCost, const std::string & name + void addAggMembers( + const ast::ReferenceToType * aggrInst, const ast::Expr * expr, + const Candidate & cand, const Cost & addedCost, const std::string & name ) { for ( const ast::Decl * decl : aggrInst->lookup( name ) ) { auto dwt = strict_dynamic_cast< const ast::DeclWithType * >( decl ); - CandidateRef newCand = std::make_shared( + CandidateRef newCand = std::make_shared( cand, new ast::MemberExpr{ expr->location, dwt, expr }, addedCost ); - // add anonymous member interpretations whenever an aggregate value type is seen + // add anonymous member interpretations whenever an aggregate value type is seen // as a member expression addAnonConversions( newCand ); @@ -815,15 +831,15 @@ /// Adds tuple member interpretations - void addTupleMembers( - const ast::TupleType * tupleType, const ast::Expr * expr, const Candidate & cand, - const Cost & addedCost, const ast::Expr * member + void addTupleMembers( + const ast::TupleType * tupleType, const ast::Expr * expr, const Candidate & cand, + const Cost & addedCost, const ast::Expr * member ) { if ( auto constantExpr = dynamic_cast< const ast::ConstantExpr * >( member ) ) { - // get the value of the constant expression as an int, must be between 0 and the + // get the value of the constant expression as an int, must be between 0 and the // length of the tuple to have meaning long long val = constantExpr->intValue(); if ( val >= 0 && (unsigned long long)val < tupleType->size() ) { addCandidate( - cand, new ast::TupleIndexExpr{ expr->location, expr, (unsigned)val }, + cand, new ast::TupleIndexExpr{ expr->location, expr, (unsigned)val }, addedCost ); } @@ -837,7 +853,9 @@ if ( funcFinder.candidates.empty() ) return; - std::vector< CandidateFinder > argCandidates = + reason.code = NoMatch; + + std::vector< CandidateFinder > argCandidates = selfFinder.findSubExprs( untypedExpr->args ); - + // take care of possible tuple assignments // if not tuple assignment, handled as normal function call @@ -877,15 +895,15 @@ if ( auto function = pointer->base.as< ast::FunctionType >() ) { CandidateRef newFunc{ new Candidate{ *func } }; - newFunc->expr = + newFunc->expr = referenceToRvalueConversion( newFunc->expr, newFunc->cost ); makeFunctionCandidates( newFunc, function, argExpansions, found ); } - } else if ( - auto inst = dynamic_cast< const ast::TypeInstType * >( funcResult ) + } else if ( + auto inst = dynamic_cast< const ast::TypeInstType * >( funcResult ) ) { if ( const ast::EqvClass * clz = func->env.lookup( inst->name ) ) { if ( auto function = clz->bound.as< ast::FunctionType >() ) { CandidateRef newFunc{ new Candidate{ *func } }; - newFunc->expr = + newFunc->expr = referenceToRvalueConversion( newFunc->expr, newFunc->cost ); makeFunctionCandidates( newFunc, function, argExpansions, found ); @@ -901,5 +919,5 @@ std::vector< ExplodedArg > funcE; funcE.reserve( funcFinder.candidates.size() ); - for ( const CandidateRef & func : funcFinder ) { + for ( const CandidateRef & func : funcFinder ) { funcE.emplace_back( *func, symtab ); } @@ -913,5 +931,5 @@ if ( auto function = pointer->base.as< ast::FunctionType >() ) { CandidateRef newOp{ new Candidate{ *op} }; - newOp->expr = + newOp->expr = referenceToRvalueConversion( newOp->expr, newOp->cost ); makeFunctionCandidates( newOp, function, argExpansions, found ); @@ -922,5 +940,5 @@ } - // Implement SFINAE; resolution errors are only errors if there aren't any non-error + // Implement SFINAE; resolution errors are only errors if there aren't any non-error // candidates if ( found.empty() && ! errors.isEmpty() ) { throw errors; } @@ -934,5 +952,5 @@ auto pointer = appExpr->func->result.strict_as< ast::PointerType >(); auto function = pointer->base.strict_as< ast::FunctionType >(); - + std::cerr << "Case +++++++++++++ " << appExpr->func << std::endl; std::cerr << "parameters are:" << std::endl; @@ -957,6 +975,6 @@ promoteCvtCost( winners ); - // function may return a struct/union value, in which case we need to add candidates - // for implicit conversions to each of the anonymous members, which must happen after + // function may return a struct/union value, in which case we need to add candidates + // for implicit conversions to each of the anonymous members, which must happen after // `findMinCost`, since anon conversions are never the cheapest for ( const CandidateRef & c : winners ) { @@ -966,5 +984,5 @@ if ( candidates.empty() && targetType && ! targetType->isVoid() ) { - // If resolution is unsuccessful with a target type, try again without, since it + // If resolution is unsuccessful with a target type, try again without, since it // will sometimes succeed when it wouldn't with a target type binding. // For example: @@ -983,5 +1001,5 @@ /// true if expression is an lvalue static bool isLvalue( const ast::Expr * x ) { - return x->result && ( x->result->is_lvalue() || x->result.as< ast::ReferenceType >() ); + return x->result && ( x->get_lvalue() || x->result.as< ast::ReferenceType >() ); } @@ -989,4 +1007,9 @@ CandidateFinder finder{ symtab, tenv }; finder.find( addressExpr->arg ); + + if( finder.candidates.empty() ) return; + + reason.code = NoMatch; + for ( CandidateRef & r : finder.candidates ) { if ( ! isLvalue( r->expr ) ) continue; @@ -1009,4 +1032,6 @@ finder.find( castExpr->arg, ResolvMode::withAdjustment() ); + if( !finder.candidates.empty() ) reason.code = NoMatch; + CandidateList matches; for ( CandidateRef & cand : finder.candidates ) { @@ -1016,7 +1041,7 @@ cand->env.extractOpenVars( open ); - // It is possible that a cast can throw away some values in a multiply-valued - // expression, e.g. cast-to-void, one value to zero. Figure out the prefix of the - // subexpression results that are cast directly. The candidate is invalid if it + // It is possible that a cast can throw away some values in a multiply-valued + // expression, e.g. cast-to-void, one value to zero. Figure out the prefix of the + // subexpression results that are cast directly. The candidate is invalid if it // has fewer results than there are types to cast to. int discardedValues = cand->expr->result->size() - toType->size(); @@ -1025,5 +1050,6 @@ // unification run for side-effects unify( toType, cand->expr->result, cand->env, need, have, open, symtab ); - Cost thisCost = castCost( cand->expr->result, toType, symtab, cand->env ); + Cost thisCost = castCost( cand->expr->result, toType, cand->expr->get_lvalue(), + symtab, cand->env ); PRINT( std::cerr << "working on cast with result: " << toType << std::endl; @@ -1037,7 +1063,7 @@ // count one safe conversion for each value that is thrown away thisCost.incSafe( discardedValues ); - CandidateRef newCand = std::make_shared( - restructureCast( cand->expr, toType, castExpr->isGenerated ), - copy( cand->env ), move( open ), move( need ), cand->cost, + CandidateRef newCand = std::make_shared( + restructureCast( cand->expr, toType, castExpr->isGenerated ), + copy( cand->env ), move( open ), move( need ), cand->cost, cand->cost + thisCost ); inferParameters( newCand, matches ); @@ -1057,6 +1083,6 @@ finder.find( castExpr->arg, ResolvMode::withoutPrune() ); for ( CandidateRef & r : finder.candidates ) { - addCandidate( - *r, + addCandidate( + *r, new ast::VirtualCastExpr{ castExpr->location, r->expr, castExpr->result } ); } @@ -1067,5 +1093,5 @@ aggFinder.find( memberExpr->aggregate, ResolvMode::withAdjustment() ); for ( CandidateRef & agg : aggFinder.candidates ) { - // it's okay for the aggregate expression to have reference type -- cast it to the + // it's okay for the aggregate expression to have reference type -- cast it to the // base type to treat the aggregate as the referenced value Cost addedCost = Cost::zero; @@ -1074,8 +1100,8 @@ // find member of the given type if ( auto structInst = agg->expr->result.as< ast::StructInstType >() ) { - addAggMembers( + addAggMembers( structInst, agg->expr, *agg, addedCost, getMemberName( memberExpr ) ); } else if ( auto unionInst = agg->expr->result.as< ast::UnionInstType >() ) { - addAggMembers( + addAggMembers( unionInst, agg->expr, *agg, addedCost, getMemberName( memberExpr ) ); } else if ( auto tupleType = agg->expr->result.as< ast::TupleType >() ) { @@ -1092,4 +1118,8 @@ std::vector< ast::SymbolTable::IdData > declList = symtab.lookupId( nameExpr->name ); PRINT( std::cerr << "nameExpr is " << nameExpr->name << std::endl; ) + if( declList.empty() ) return; + + reason.code = NoMatch; + for ( auto & data : declList ) { Cost cost = Cost::zero; @@ -1097,5 +1127,5 @@ CandidateRef newCand = std::make_shared( - newExpr, copy( tenv ), ast::OpenVarSet{}, ast::AssertionSet{}, Cost::zero, + newExpr, copy( tenv ), ast::OpenVarSet{}, ast::AssertionSet{}, Cost::zero, cost ); PRINT( @@ -1107,8 +1137,8 @@ std::cerr << std::endl; ) - newCand->expr = ast::mutate_field( - newCand->expr.get(), &ast::Expr::result, + newCand->expr = ast::mutate_field( + newCand->expr.get(), &ast::Expr::result, renameTyVars( newCand->expr->result ) ); - // add anonymous member interpretations whenever an aggregate value type is seen + // add anonymous member interpretations whenever an aggregate value type is seen // as a name expression addAnonConversions( newCand ); @@ -1120,5 +1150,5 @@ // not sufficient to just pass `variableExpr` here, type might have changed since // creation - addCandidate( + addCandidate( new ast::VariableExpr{ variableExpr->location, variableExpr->var }, tenv ); } @@ -1130,7 +1160,7 @@ void postvisit( const ast::SizeofExpr * sizeofExpr ) { if ( sizeofExpr->type ) { - addCandidate( - new ast::SizeofExpr{ - sizeofExpr->location, resolveTypeof( sizeofExpr->type, symtab ) }, + addCandidate( + new ast::SizeofExpr{ + sizeofExpr->location, resolveTypeof( sizeofExpr->type, symtab ) }, tenv ); } else { @@ -1141,5 +1171,5 @@ CandidateList winners = findMinCost( finder.candidates ); if ( winners.size() != 1 ) { - SemanticError( + SemanticError( sizeofExpr->expr.get(), "Ambiguous expression in sizeof operand: " ); } @@ -1154,7 +1184,7 @@ void postvisit( const ast::AlignofExpr * alignofExpr ) { if ( alignofExpr->type ) { - addCandidate( - new ast::AlignofExpr{ - alignofExpr->location, resolveTypeof( alignofExpr->type, symtab ) }, + addCandidate( + new ast::AlignofExpr{ + alignofExpr->location, resolveTypeof( alignofExpr->type, symtab ) }, tenv ); } else { @@ -1165,5 +1195,5 @@ CandidateList winners = findMinCost( finder.candidates ); if ( winners.size() != 1 ) { - SemanticError( + SemanticError( alignofExpr->expr.get(), "Ambiguous expression in alignof operand: " ); } @@ -1172,5 +1202,5 @@ choice->expr = referenceToRvalueConversion( choice->expr, choice->cost ); choice->cost = Cost::zero; - addCandidate( + addCandidate( *choice, new ast::AlignofExpr{ alignofExpr->location, choice->expr } ); } @@ -1185,5 +1215,5 @@ for ( const ast::Decl * member : aggInst->lookup( offsetofExpr->member ) ) { auto dwt = strict_dynamic_cast< const ast::DeclWithType * >( member ); - addCandidate( + addCandidate( new ast::OffsetofExpr{ offsetofExpr->location, aggInst, dwt }, tenv ); } @@ -1206,4 +1236,6 @@ finder2.find( logicalExpr->arg2, ResolvMode::withAdjustment() ); if ( finder2.candidates.empty() ) return; + + reason.code = NoMatch; for ( const CandidateRef & r1 : finder1.candidates ) { @@ -1218,5 +1250,5 @@ addCandidate( - new ast::LogicalExpr{ + new ast::LogicalExpr{ logicalExpr->location, r1->expr, r2->expr, logicalExpr->isAnd }, move( env ), move( open ), move( need ), r1->cost + r2->cost ); @@ -1240,4 +1272,6 @@ finder3.find( conditionalExpr->arg3, ResolvMode::withAdjustment() ); if ( finder3.candidates.empty() ) return; + + reason.code = NoMatch; for ( const CandidateRef & r1 : finder1.candidates ) { @@ -1256,19 +1290,19 @@ ast::AssertionSet have; - // unify true and false results, then infer parameters to produce new + // unify true and false results, then infer parameters to produce new // candidates ast::ptr< ast::Type > common; - if ( - unify( - r2->expr->result, r3->expr->result, env, need, have, open, symtab, - common ) + if ( + unify( + r2->expr->result, r3->expr->result, env, need, have, open, symtab, + common ) ) { // generate typed expression - ast::ConditionalExpr * newExpr = new ast::ConditionalExpr{ + ast::ConditionalExpr * newExpr = new ast::ConditionalExpr{ conditionalExpr->location, r1->expr, r2->expr, r3->expr }; newExpr->result = common ? common : r2->expr->result; // convert both options to result type Cost cost = r1->cost + r2->cost + r3->cost; - newExpr->arg2 = computeExpressionConversionCost( + newExpr->arg2 = computeExpressionConversionCost( newExpr->arg2, newExpr->result, symtab, env, cost ); newExpr->arg3 = computeExpressionConversionCost( @@ -1287,5 +1321,5 @@ ast::TypeEnvironment env{ tenv }; ast::ptr< ast::Expr > arg1 = resolveInVoidContext( commaExpr->arg1, symtab, env ); - + CandidateFinder finder2{ symtab, env }; finder2.find( commaExpr->arg2, ResolvMode::withAdjustment() ); @@ -1317,4 +1351,6 @@ finder2.find( rangeExpr->high, ResolvMode::withAdjustment() ); if ( finder2.candidates.empty() ) return; + + reason.code = NoMatch; for ( const CandidateRef & r1 : finder1.candidates ) { @@ -1330,16 +1366,16 @@ ast::ptr< ast::Type > common; - if ( - unify( - r1->expr->result, r2->expr->result, env, need, have, open, symtab, - common ) + if ( + unify( + r1->expr->result, r2->expr->result, env, need, have, open, symtab, + common ) ) { // generate new expression - ast::RangeExpr * newExpr = + ast::RangeExpr * newExpr = new ast::RangeExpr{ rangeExpr->location, r1->expr, r2->expr }; newExpr->result = common ? common : r1->expr->result; // add candidate CandidateRef newCand = std::make_shared( - newExpr, move( env ), move( open ), move( need ), + newExpr, move( env ), move( open ), move( need ), r1->cost + r2->cost ); inferParameters( newCand, candidates ); @@ -1350,5 +1386,5 @@ void postvisit( const ast::UntypedTupleExpr * tupleExpr ) { - std::vector< CandidateFinder > subCandidates = + std::vector< CandidateFinder > subCandidates = selfFinder.findSubExprs( tupleExpr->exprs ); std::vector< CandidateList > possibilities; @@ -1370,5 +1406,5 @@ addCandidate( - new ast::TupleExpr{ tupleExpr->location, move( exprs ) }, + new ast::TupleExpr{ tupleExpr->location, move( exprs ) }, move( env ), move( open ), move( need ), sumCost( subs ) ); } @@ -1412,10 +1448,12 @@ toType = SymTab::validateType( initExpr->location, toType, symtab ); toType = adjustExprType( toType, tenv, symtab ); - // The call to find must occur inside this loop, otherwise polymorphic return - // types are not bound to the initialization type, since return type variables are - // only open for the duration of resolving the UntypedExpr. + // The call to find must occur inside this loop, otherwise polymorphic return + // types are not bound to the initialization type, since return type variables are + // only open for the duration of resolving the UntypedExpr. CandidateFinder finder{ symtab, tenv, toType }; finder.find( initExpr->expr, ResolvMode::withAdjustment() ); for ( CandidateRef & cand : finder.candidates ) { + if(reason.code == NotFound) reason.code = NoMatch; + ast::TypeEnvironment env{ cand->env }; ast::AssertionSet need( cand->need.begin(), cand->need.end() ), have; @@ -1426,7 +1464,7 @@ ) - // It is possible that a cast can throw away some values in a multiply-valued - // expression, e.g. cast-to-void, one value to zero. Figure out the prefix of - // the subexpression results that are cast directly. The candidate is invalid + // It is possible that a cast can throw away some values in a multiply-valued + // expression, e.g. cast-to-void, one value to zero. Figure out the prefix of + // the subexpression results that are cast directly. The candidate is invalid // if it has fewer results than there are types to cast to. int discardedValues = cand->expr->result->size() - toType->size(); @@ -1435,13 +1473,14 @@ // unification run for side-effects unify( toType, cand->expr->result, env, need, have, open, symtab ); - Cost thisCost = castCost( cand->expr->result, toType, symtab, env ); - + Cost thisCost = castCost( cand->expr->result, toType, cand->expr->get_lvalue(), + symtab, env ); + if ( thisCost != Cost::infinity ) { // count one safe conversion for each value that is thrown away thisCost.incSafe( discardedValues ); - CandidateRef newCand = std::make_shared( - new ast::InitExpr{ - initExpr->location, restructureCast( cand->expr, toType ), - initAlt.designation }, + CandidateRef newCand = std::make_shared( + new ast::InitExpr{ + initExpr->location, restructureCast( cand->expr, toType ), + initAlt.designation }, copy( cand->env ), move( open ), move( need ), cand->cost, thisCost ); inferParameters( newCand, matches ); @@ -1469,5 +1508,6 @@ }; - /// Prunes a list of candidates down to those that have the minimum conversion cost for a given + // size_t Finder::traceId = Stats::Heap::new_stacktrace_id("Finder"); + /// Prunes a list of candidates down to those that have the minimum conversion cost for a given /// return type. Skips ambiguous candidates. CandidateList pruneCandidates( CandidateList & candidates ) { @@ -1486,4 +1526,5 @@ { ast::ptr< ast::Type > newType = candidate->expr->result; + assertf(candidate->expr->result, "Result of expression %p for candidate is null", candidate->expr.get()); candidate->env.apply( newType ); mangleName = Mangle::mangle( newType ); @@ -1494,5 +1535,5 @@ if ( candidate->cost < found->second.candidate->cost ) { PRINT( - std::cerr << "cost " << candidate->cost << " beats " + std::cerr << "cost " << candidate->cost << " beats " << found->second.candidate->cost << std::endl; ) @@ -1500,6 +1541,6 @@ found->second = PruneStruct{ candidate }; } else if ( candidate->cost == found->second.candidate->cost ) { - // if one of the candidates contains a deleted identifier, can pick the other, - // since deleted expressions should not be ambiguous if there is another option + // if one of the candidates contains a deleted identifier, can pick the other, + // since deleted expressions should not be ambiguous if there is another option // that is at least as good if ( findDeletedExpr( candidate->expr ) ) { @@ -1515,5 +1556,5 @@ } else { PRINT( - std::cerr << "cost " << candidate->cost << " loses to " + std::cerr << "cost " << candidate->cost << " loses to " << found->second.candidate->cost << std::endl; ) @@ -1530,10 +1571,10 @@ CandidateRef cand = target.second.candidate; - + ast::ptr< ast::Type > newResult = cand->expr->result; cand->env.applyFree( newResult ); cand->expr = ast::mutate_field( cand->expr.get(), &ast::Expr::result, move( newResult ) ); - + out.emplace_back( cand ); } @@ -1549,5 +1590,17 @@ if ( mode.failFast && candidates.empty() ) { - SemanticError( expr, "No reasonable alternatives for expression " ); + switch(finder.core.reason.code) { + case Finder::NotFound: + { SemanticError( expr, "No alternatives for expression " ); break; } + case Finder::NoMatch: + { SemanticError( expr, "Invalid application of existing declaration(s) in expression " ); break; } + case Finder::ArgsToFew: + case Finder::ArgsToMany: + case Finder::RetsToFew: + case Finder::RetsToMany: + case Finder::NoReason: + default: + { SemanticError( expr->location, "No reasonable alternatives for expression : reasons unkown" ); } + } } @@ -1558,5 +1611,5 @@ std::vector< std::string > errors; for ( CandidateRef & candidate : candidates ) { - satisfyAssertions( candidate, symtab, satisfied, errors ); + satisfyAssertions( candidate, localSyms, satisfied, errors ); } @@ -1583,5 +1636,5 @@ CandidateList pruned = pruneCandidates( candidates ); - + if ( mode.failFast && pruned.empty() ) { std::ostringstream stream; @@ -1602,16 +1655,16 @@ ) PRINT( - std::cerr << "there are " << candidates.size() << " alternatives after elimination" + std::cerr << "there are " << candidates.size() << " alternatives after elimination" << std::endl; ) } - // adjust types after pruning so that types substituted by pruneAlternatives are correctly + // adjust types after pruning so that types substituted by pruneAlternatives are correctly // adjusted if ( mode.adjust ) { for ( CandidateRef & r : candidates ) { - r->expr = ast::mutate_field( - r->expr.get(), &ast::Expr::result, - adjustExprType( r->expr->result, r->env, symtab ) ); + r->expr = ast::mutate_field( + r->expr.get(), &ast::Expr::result, + adjustExprType( r->expr->result, r->env, localSyms ) ); } } @@ -1625,13 +1678,13 @@ } -std::vector< CandidateFinder > CandidateFinder::findSubExprs( - const std::vector< ast::ptr< ast::Expr > > & xs +std::vector< CandidateFinder > CandidateFinder::findSubExprs( + const std::vector< ast::ptr< ast::Expr > > & xs ) { std::vector< CandidateFinder > out; for ( const auto & x : xs ) { - out.emplace_back( symtab, env ); + out.emplace_back( localSyms, env ); out.back().find( x, ResolvMode::withAdjustment() ); - + PRINT( std::cerr << "findSubExprs" << std::endl; Index: src/ResolvExpr/CandidateFinder.hpp =================================================================== --- src/ResolvExpr/CandidateFinder.hpp (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/ResolvExpr/CandidateFinder.hpp (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -9,7 +9,7 @@ // Author : Aaron B. Moss // Created On : Wed Jun 5 14:30:00 2019 -// Last Modified By : Aaron B. Moss -// Last Modified On : Wed Jun 5 14:30:00 2019 -// Update Count : 1 +// Last Modified By : Andrew Beach +// Last Modified On : Tue Oct 1 9:51:00 2019 +// Update Count : 2 // @@ -28,12 +28,12 @@ struct CandidateFinder { CandidateList candidates; ///< List of candidate resolutions - const ast::SymbolTable & symtab; ///< Symbol table to lookup candidates + const ast::SymbolTable & localSyms; ///< Symbol table to lookup candidates const ast::TypeEnvironment & env; ///< Substitutions performed in this resolution ast::ptr< ast::Type > targetType; ///< Target type for resolution - CandidateFinder( - const ast::SymbolTable & symtab, const ast::TypeEnvironment & env, + CandidateFinder( + const ast::SymbolTable & syms, const ast::TypeEnvironment & env, const ast::Type * tt = nullptr ) - : candidates(), symtab( symtab ), env( env ), targetType( tt ) {} + : candidates(), localSyms( syms ), env( env ), targetType( tt ) {} /// Fill candidates with feasible resolutions for `expr` @@ -49,5 +49,5 @@ iterator begin() { return candidates.begin(); } const_iterator begin() const { return candidates.begin(); } - + iterator end() { return candidates.end(); } const_iterator end() const { return candidates.end(); } @@ -55,7 +55,7 @@ /// Computes conversion cost between two types -Cost computeConversionCost( - const ast::Type * argType, const ast::Type * paramType, const ast::SymbolTable & symtab, - const ast::TypeEnvironment & env ); +Cost computeConversionCost( + const ast::Type * argType, const ast::Type * paramType, bool argIsLvalue, + const ast::SymbolTable & symtab, const ast::TypeEnvironment & env ); } // namespace ResolvExpr Index: src/ResolvExpr/CastCost.cc =================================================================== --- src/ResolvExpr/CastCost.cc (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/ResolvExpr/CastCost.cc (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -10,6 +10,6 @@ // Created On : Sun May 17 06:57:43 2015 // Last Modified By : Andrew Beach -// Last Modified On : Thu Aug 8 16:12:00 2019 -// Update Count : 8 +// Last Modified On : Tue Oct 4 15:00:00 2019 +// Update Count : 9 // @@ -142,7 +142,7 @@ CastCost_new( - const ast::Type * dst, const ast::SymbolTable & symtab, + const ast::Type * dst, bool srcIsLvalue, const ast::SymbolTable & symtab, const ast::TypeEnvironment & env, CostCalculation costFunc ) - : ConversionCost_new( dst, symtab, env, costFunc ) {} + : ConversionCost_new( dst, srcIsLvalue, symtab, env, costFunc ) {} void postvisit( const ast::BasicType * basicType ) { @@ -152,5 +152,5 @@ cost = Cost::unsafe; } else { - cost = conversionCost( basicType, dst, symtab, env ); + cost = conversionCost( basicType, dst, srcIsLvalue, symtab, env ); } } @@ -183,9 +183,21 @@ } }; + + #warning For overload resolution between the two versions. + int localPtrsCastable(const ast::Type * t1, const ast::Type * t2, + const ast::SymbolTable & symtab, const ast::TypeEnvironment & env ) { + return ptrsCastable( t1, t2, symtab, env ); + } + Cost localCastCost( + const ast::Type * src, const ast::Type * dst, bool srcIsLvalue, + const ast::SymbolTable & symtab, const ast::TypeEnvironment & env + ) { return castCost( src, dst, srcIsLvalue, symtab, env ); } } // anonymous namespace + + Cost castCost( - const ast::Type * src, const ast::Type * dst, const ast::SymbolTable & symtab, - const ast::TypeEnvironment & env + const ast::Type * src, const ast::Type * dst, bool srcIsLvalue, + const ast::SymbolTable & symtab, const ast::TypeEnvironment & env ) { if ( auto typeInst = dynamic_cast< const ast::TypeInstType * >( dst ) ) { @@ -193,5 +205,5 @@ // check cast cost against bound type, if present if ( eqvClass->bound ) { - return castCost( src, eqvClass->bound, symtab, env ); + return castCost( src, eqvClass->bound, srcIsLvalue, symtab, env ); } else { return Cost::infinity; @@ -201,5 +213,5 @@ auto type = strict_dynamic_cast< const ast::TypeDecl * >( named ); if ( type->base ) { - return castCost( src, type->base, symtab, env ) + Cost::safe; + return castCost( src, type->base, srcIsLvalue, symtab, env ) + Cost::safe; } } @@ -224,19 +236,11 @@ #warning cast on ptrsCastable artifact of having two functions, remove when port done return convertToReferenceCost( - src, refType, symtab, env, - ( int (*)( - const ast::Type *, const ast::Type *, const ast::SymbolTable &, - const ast::TypeEnvironment & ) - ) ptrsCastable ); + src, refType, srcIsLvalue, symtab, env, localPtrsCastable ); } else { #warning cast on castCost artifact of having two functions, remove when port done - ast::Pass< CastCost_new > converter{ - dst, symtab, env, - ( Cost (*)( - const ast::Type *, const ast::Type *, const ast::SymbolTable &, - const ast::TypeEnvironment & ) - ) castCost }; + ast::Pass< CastCost_new > converter( + dst, srcIsLvalue, symtab, env, localCastCost ); src->accept( converter ); - return converter.pass.cost; + return converter.core.cost; } } Index: src/ResolvExpr/CommonType.cc =================================================================== --- src/ResolvExpr/CommonType.cc (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/ResolvExpr/CommonType.cc (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -666,4 +666,5 @@ const ast::OpenVarSet & open; public: + static size_t traceId; ast::ptr< ast::Type > result; @@ -893,4 +894,5 @@ }; + // size_t CommonType_new::traceId = Stats::Heap::new_stacktrace_id("CommonType_new"); namespace { ast::ptr< ast::Type > handleReference( @@ -939,5 +941,5 @@ ast::ptr< ast::Type > result; const ast::ReferenceType * ref1 = type1.as< ast::ReferenceType >(); - const ast::ReferenceType * ref2 = type1.as< ast::ReferenceType >(); + const ast::ReferenceType * ref2 = type2.as< ast::ReferenceType >(); if ( depth1 > depth2 ) { @@ -966,5 +968,5 @@ ast::Pass visitor{ type2, widen, symtab, env, open }; type1->accept( visitor ); - ast::ptr< ast::Type > result = visitor.pass.result; + ast::ptr< ast::Type > result = visitor.core.result; // handling for opaque type declarations (?) Index: src/ResolvExpr/ConversionCost.cc =================================================================== --- src/ResolvExpr/ConversionCost.cc (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/ResolvExpr/ConversionCost.cc (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -481,24 +481,24 @@ } -static int localPtrsAssignable(const ast::Type * t1, const ast::Type * t2, - const ast::SymbolTable &, const ast::TypeEnvironment & env ) { - return ptrsAssignable( t1, t2, env ); -} - -// TODO: This is used for overload resolution. It might be able to be dropped once the old system -// is removed. -static Cost localConversionCost( - const ast::Type * src, const ast::Type * dst, const ast::SymbolTable & symtab, - const ast::TypeEnvironment & env -) { return conversionCost( src, dst, symtab, env ); } +namespace { + # warning For overload resolution between the two versions. + int localPtrsAssignable(const ast::Type * t1, const ast::Type * t2, + const ast::SymbolTable &, const ast::TypeEnvironment & env ) { + return ptrsAssignable( t1, t2, env ); + } + Cost localConversionCost( + const ast::Type * src, const ast::Type * dst, bool srcIsLvalue, + const ast::SymbolTable & symtab, const ast::TypeEnvironment & env + ) { return conversionCost( src, dst, srcIsLvalue, symtab, env ); } +} Cost conversionCost( - const ast::Type * src, const ast::Type * dst, const ast::SymbolTable & symtab, - const ast::TypeEnvironment & env + const ast::Type * src, const ast::Type * dst, bool srcIsLvalue, + const ast::SymbolTable & symtab, const ast::TypeEnvironment & env ) { if ( const ast::TypeInstType * inst = dynamic_cast< const ast::TypeInstType * >( dst ) ) { if ( const ast::EqvClass * eqv = env.lookup( inst->name ) ) { if ( eqv->bound ) { - return conversionCost(src, eqv->bound, symtab, env ); + return conversionCost(src, eqv->bound, srcIsLvalue, symtab, env ); } else { return Cost::infinity; @@ -508,5 +508,5 @@ assertf( type, "Unexpected typedef." ); if ( type->base ) { - return conversionCost( src, type->base, symtab, env ) + Cost::safe; + return conversionCost( src, type->base, srcIsLvalue, symtab, env ) + Cost::safe; } } @@ -518,19 +518,19 @@ } else if ( const ast::ReferenceType * refType = dynamic_cast< const ast::ReferenceType * >( dst ) ) { - return convertToReferenceCost( src, refType, symtab, env, localPtrsAssignable ); + return convertToReferenceCost( src, refType, srcIsLvalue, symtab, env, localPtrsAssignable ); } else { - ast::Pass converter( dst, symtab, env, localConversionCost ); + ast::Pass converter( dst, srcIsLvalue, symtab, env, localConversionCost ); src->accept( converter ); - return converter.pass.cost; - } -} - -static Cost convertToReferenceCost( const ast::Type * src, const ast::Type * dst, + return converter.core.cost; + } +} + +static Cost convertToReferenceCost( const ast::Type * src, const ast::Type * dst, bool srcIsLvalue, int diff, const ast::SymbolTable & symtab, const ast::TypeEnvironment & env, - NumCostCalculation func ) { + PtrsCalculation func ) { if ( 0 < diff ) { Cost cost = convertToReferenceCost( - strict_dynamic_cast< const ast::ReferenceType * >( src )->base, - dst, (diff - 1), symtab, env, func ); + strict_dynamic_cast< const ast::ReferenceType * >( src )->base, dst, + srcIsLvalue, (diff - 1), symtab, env, func ); cost.incReference(); return cost; @@ -538,5 +538,5 @@ Cost cost = convertToReferenceCost( src, strict_dynamic_cast< const ast::ReferenceType * >( dst )->base, - (diff + 1), symtab, env, func ); + srcIsLvalue, (diff + 1), symtab, env, func ); cost.incReference(); return cost; @@ -563,7 +563,7 @@ } } else { - ast::Pass converter( dst, symtab, env, localConversionCost ); + ast::Pass converter( dst, srcIsLvalue, symtab, env, localConversionCost ); src->accept( converter ); - return converter.pass.cost; + return converter.core.cost; } } else { @@ -572,5 +572,5 @@ assert( dstAsRef ); if ( typesCompatibleIgnoreQualifiers( src, dstAsRef->base, symtab, env ) ) { - if ( src->is_lvalue() ) { + if ( srcIsLvalue ) { if ( src->qualifiers == dstAsRef->base->qualifiers ) { return Cost::reference; @@ -591,8 +591,8 @@ Cost convertToReferenceCost( const ast::Type * src, const ast::ReferenceType * dst, - const ast::SymbolTable & symtab, const ast::TypeEnvironment & env, - NumCostCalculation func ) { + bool srcIsLvalue, const ast::SymbolTable & symtab, const ast::TypeEnvironment & env, + PtrsCalculation func ) { int sdepth = src->referenceDepth(), ddepth = dst->referenceDepth(); - return convertToReferenceCost( src, dst, sdepth - ddepth, symtab, env, func ); + return convertToReferenceCost( src, dst, srcIsLvalue, sdepth - ddepth, symtab, env, func ); } @@ -651,5 +651,5 @@ assert( nullptr == dynamic_cast< const ast::ReferenceType * >( dst ) ); - cost = costCalc( refType->base, dst, symtab, env ); + cost = costCalc( refType->base, dst, srcIsLvalue, symtab, env ); if ( refType->base->qualifiers == dst->qualifiers ) { cost.incReference(); @@ -667,6 +667,6 @@ void ConversionCost_new::postvisit( const ast::EnumInstType * enumInstType ) { (void)enumInstType; - static const ast::BasicType integer( ast::BasicType::SignedInt ); - cost = costCalc( &integer, dst, symtab, env ); + static ast::ptr integer = { new ast::BasicType( ast::BasicType::SignedInt ) }; + cost = costCalc( integer, dst, srcIsLvalue, symtab, env ); if ( cost < Cost::unsafe ) { cost.incSafe(); @@ -680,5 +680,5 @@ void ConversionCost_new::postvisit( const ast::TypeInstType * typeInstType ) { if ( const ast::EqvClass * eqv = env.lookup( typeInstType->name ) ) { - cost = costCalc( eqv->bound, dst, symtab, env ); + cost = costCalc( eqv->bound, dst, srcIsLvalue, symtab, env ); } else if ( const ast::TypeInstType * dstAsInst = dynamic_cast< const ast::TypeInstType * >( dst ) ) { @@ -690,5 +690,5 @@ assertf( type, "Unexpected typedef."); if ( type->base ) { - cost = costCalc( type->base, dst, symtab, env ) + Cost::safe; + cost = costCalc( type->base, dst, srcIsLvalue, symtab, env ) + Cost::safe; } } @@ -703,5 +703,5 @@ auto dstEnd = dstAsTuple->types.end(); while ( srcIt != srcEnd && dstIt != dstEnd ) { - Cost newCost = costCalc( * srcIt++, * dstIt++, symtab, env ); + Cost newCost = costCalc( * srcIt++, * dstIt++, srcIsLvalue, symtab, env ); if ( newCost == Cost::infinity ) { return; @@ -738,4 +738,8 @@ cost.incSign( signMatrix[ ast::BasicType::SignedInt ][ dstAsBasic->kind ] ); } + } else if ( dynamic_cast< const ast::PointerType * >( dst ) ) { + cost = Cost::zero; + // +1 for zero_t ->, +1 for disambiguation + cost.incSafe( maxIntCost + 2 ); } } @@ -755,10 +759,7 @@ cost.incSign( signMatrix[ ast::BasicType::SignedInt ][ dstAsBasic->kind ] ); } - } else if ( dynamic_cast< const ast::PointerType * >( dst ) ) { - cost = Cost::zero; - cost.incSafe( maxIntCost + 2 ); - } -} - + } +} +// size_t ConversionCost_new::traceId = Stats::Heap::new_stacktrace_id("ConversionCost"); } // namespace ResolvExpr Index: src/ResolvExpr/ConversionCost.h =================================================================== --- src/ResolvExpr/ConversionCost.h (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/ResolvExpr/ConversionCost.h (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -72,7 +72,7 @@ // Some function pointer types, differ in return type. -using CostCalculation = std::function; -using NumCostCalculation = std::function; @@ -81,13 +81,16 @@ protected: const ast::Type * dst; + bool srcIsLvalue; const ast::SymbolTable & symtab; const ast::TypeEnvironment & env; CostCalculation costCalc; public: + static size_t traceId; Cost cost; - ConversionCost_new( const ast::Type * dst, const ast::SymbolTable & symtab, + ConversionCost_new( const ast::Type * dst, bool srcIsLvalue, const ast::SymbolTable & symtab, const ast::TypeEnvironment & env, CostCalculation costCalc ) : - dst( dst ), symtab( symtab ), env( env ), costCalc( costCalc ), cost( Cost::infinity ) + dst( dst ), srcIsLvalue( srcIsLvalue ), symtab( symtab ), env( env ), + costCalc( costCalc ), cost( Cost::infinity ) {} @@ -110,5 +113,6 @@ Cost convertToReferenceCost( const ast::Type * src, const ast::ReferenceType * dest, - const ast::SymbolTable & indexer, const ast::TypeEnvironment & env, NumCostCalculation func ); + bool srcIsLvalue, const ast::SymbolTable & indexer, const ast::TypeEnvironment & env, + PtrsCalculation func ); } // namespace ResolvExpr Index: src/ResolvExpr/CurrentObject.cc =================================================================== --- src/ResolvExpr/CurrentObject.cc (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/ResolvExpr/CurrentObject.cc (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -21,8 +21,10 @@ #include // for string, operator<<, allocator +#include "AST/Copy.hpp" // for shallowCopy #include "AST/Expr.hpp" // for InitAlternative #include "AST/GenericSubstitution.hpp" // for genericSubstitution #include "AST/Init.hpp" // for Designation #include "AST/Node.hpp" // for readonly +#include "AST/Print.hpp" // for readonly #include "AST/Type.hpp" #include "Common/Indenter.h" // for Indenter, operator<< @@ -596,6 +598,6 @@ SimpleIterator( const CodeLocation & loc, const Type * t ) : location( loc ), type( t ) {} - void setPosition( - std::deque< ptr< Expr > >::const_iterator begin, + void setPosition( + std::deque< ptr< Expr > >::const_iterator begin, std::deque< ptr< Expr > >::const_iterator end ) override { @@ -637,5 +639,5 @@ auto res = eval(expr); if ( ! res.second ) { - SemanticError( location, + SemanticError( location, toString("Array designator must be a constant expression: ", expr ) ); } @@ -644,5 +646,5 @@ public: - ArrayIterator( const CodeLocation & loc, const ArrayType * at ) + ArrayIterator( const CodeLocation & loc, const ArrayType * at ) : location( loc ), array( at ), base( at->base ) { PRINT( std::cerr << "Creating array iterator: " << at << std::endl; ) @@ -655,6 +657,6 @@ void setPosition( const Expr * expr ) { - // need to permit integer-constant-expressions, including: integer constants, - // enumeration constants, character constants, sizeof expressions, alignof expressions, + // need to permit integer-constant-expressions, including: integer constants, + // enumeration constants, character constants, sizeof expressions, alignof expressions, // cast expressions if ( auto constExpr = dynamic_cast< const ConstantExpr * >( expr ) ) { @@ -662,22 +664,22 @@ index = constExpr->intValue(); } catch ( SemanticErrorException & ) { - SemanticError( expr, + SemanticError( expr, "Constant expression of non-integral type in array designator: " ); } } else if ( auto castExpr = dynamic_cast< const CastExpr * >( expr ) ) { setPosition( castExpr->arg ); - } else if ( - dynamic_cast< const SizeofExpr * >( expr ) - || dynamic_cast< const AlignofExpr * >( expr ) + } else if ( + dynamic_cast< const SizeofExpr * >( expr ) + || dynamic_cast< const AlignofExpr * >( expr ) ) { index = 0; } else { - assertf( false, + assertf( false, "bad designator given to ArrayIterator: %s", toString( expr ).c_str() ); } } - void setPosition( - std::deque< ptr< Expr > >::const_iterator begin, + void setPosition( + std::deque< ptr< Expr > >::const_iterator begin, std::deque< ptr< Expr > >::const_iterator end ) override { @@ -758,8 +760,8 @@ } - AggregateIterator( - const CodeLocation & loc, const std::string k, const std::string & n, const Type * i, + AggregateIterator( + const CodeLocation & loc, const std::string k, const std::string & n, const Type * i, const MemberList & ms ) - : location( loc ), kind( k ), name( n ), inst( i ), members( ms ), curMember( ms.begin() ), + : location( loc ), kind( k ), name( n ), inst( i ), members( ms ), curMember( ms.begin() ), sub( genericSubstitution( i ) ) { PRINT( std::cerr << "Creating " << kind << "(" << name << ")"; ) @@ -768,6 +770,6 @@ public: - void setPosition( - std::deque< ptr< Expr > >::const_iterator begin, + void setPosition( + std::deque< ptr< Expr > >::const_iterator begin, std::deque< ptr< Expr > >::const_iterator end ) final { @@ -786,8 +788,8 @@ return; } - assertf( false, + assertf( false, "could not find member in %s: %s", kind.c_str(), toString( varExpr ).c_str() ); } else { - assertf( false, + assertf( false, "bad designator given to %s: %s", kind.c_str(), toString( *begin ).c_str() ); } @@ -803,4 +805,5 @@ new VariableExpr{ location, curMember->strict_as< ObjectDecl >() } ); // need to substitute for generic types so that casts are to concrete types + alt.type = shallowCopy(alt.type.get()); PRINT( std::cerr << " type is: " << alt.type; ) sub.apply( alt.type ); // also apply to designation?? @@ -842,5 +845,5 @@ for ( InitAlternative & alt : ret ) { PRINT( std::cerr << "iterating and adding designators" << std::endl; ) - alt.designation.get_and_mutate()->designators.emplace_front( + alt.designation.get_and_mutate()->designators.emplace_front( new VariableExpr{ location, curMember->strict_as< ObjectDecl >() } ); } @@ -897,7 +900,7 @@ class TupleIterator final : public AggregateIterator { public: - TupleIterator( const CodeLocation & loc, const TupleType * inst ) - : AggregateIterator( - loc, "TupleIterator", toString("Tuple", inst->size()), inst, inst->members + TupleIterator( const CodeLocation & loc, const TupleType * inst ) + : AggregateIterator( + loc, "TupleIterator", toString("Tuple", inst->size()), inst, inst->members ) {} @@ -926,7 +929,7 @@ return new UnionIterator{ loc, uit }; } else { - assertf( - dynamic_cast< const EnumInstType * >( aggr ) - || dynamic_cast< const TypeInstType * >( aggr ), + assertf( + dynamic_cast< const EnumInstType * >( type ) + || dynamic_cast< const TypeInstType * >( type ), "Encountered unhandled ReferenceToType in createMemberIterator: %s", toString( type ).c_str() ); @@ -949,5 +952,5 @@ using DesignatorChain = std::deque< ptr< Expr > >; PRINT( std::cerr << "___findNext" << std::endl; ) - + // find all the d's std::vector< DesignatorChain > desigAlts{ {} }, newDesigAlts; @@ -1013,5 +1016,5 @@ // set new designators assertf( ! objStack.empty(), "empty object stack when setting designation" ); - Designation * actualDesignation = + Designation * actualDesignation = new Designation{ designation->location, DesignatorChain{d} }; objStack.back()->setPosition( d ); // destroys d Index: src/ResolvExpr/PolyCost.cc =================================================================== --- src/ResolvExpr/PolyCost.cc (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/ResolvExpr/PolyCost.cc (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -58,11 +58,12 @@ // TODO: When the old PolyCost is torn out get rid of the _new suffix. -struct PolyCost_new { +class PolyCost_new { + const ast::SymbolTable &symtab; +public: int result; - const ast::SymbolTable &symtab; const ast::TypeEnvironment &env_; - PolyCost_new( const ast::SymbolTable & symtab, const ast::TypeEnvironment & env ) : - result( 0 ), symtab( symtab ), env_( env ) {} + PolyCost_new( const ast::SymbolTable & symtab, const ast::TypeEnvironment & env ) + : symtab( symtab ), result( 0 ), env_( env ) {} void previsit( const ast::TypeInstType * type ) { @@ -86,5 +87,5 @@ ast::Pass costing( symtab, env ); type->accept( costing ); - return costing.pass.result; + return costing.core.result; } Index: src/ResolvExpr/PtrsAssignable.cc =================================================================== --- src/ResolvExpr/PtrsAssignable.cc (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/ResolvExpr/PtrsAssignable.cc (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -155,5 +155,5 @@ ast::Pass visitor( dst, env ); src->accept( visitor ); - return visitor.pass.result; + return visitor.core.result; } Index: src/ResolvExpr/PtrsCastable.cc =================================================================== --- src/ResolvExpr/PtrsCastable.cc (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/ResolvExpr/PtrsCastable.cc (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -293,5 +293,5 @@ ast::Pass< PtrsCastable_new > ptrs{ dst, env, symtab }; src->accept( ptrs ); - return ptrs.pass.result; + return ptrs.core.result; } } Index: src/ResolvExpr/RenameVars.cc =================================================================== --- src/ResolvExpr/RenameVars.cc (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/ResolvExpr/RenameVars.cc (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -19,4 +19,5 @@ #include // for pair +#include "AST/ForallSubstitutionTable.hpp" #include "AST/Pass.hpp" #include "AST/Type.hpp" @@ -30,4 +31,6 @@ #include "SynTree/Visitor.h" // for acceptAll, maybeAccept +#include "AST/Copy.hpp" + namespace ResolvExpr { @@ -37,6 +40,7 @@ int resetCount = 0; ScopedMap< std::string, std::string > nameMap; + public: + ast::ForallSubstitutionTable subs; - public: void reset() { level = 0; @@ -44,8 +48,6 @@ } - using mapConstIterator = ScopedMap< std::string, std::string >::const_iterator; - void rename( TypeInstType * type ) { - mapConstIterator it = nameMap.find( type->name ); + auto it = nameMap.find( type->name ); if ( it != nameMap.end() ) { type->name = it->second; @@ -65,7 +67,6 @@ // ditto for assertion names, the next level in level++; - // acceptAll( td->assertions, *this ); - } // for - } // if + } + } } @@ -77,10 +78,16 @@ const ast::TypeInstType * rename( const ast::TypeInstType * type ) { - mapConstIterator it = nameMap.find( type->name ); + // re-linking of base type handled by WithForallSubstitutor + + // rename + auto it = nameMap.find( type->name ); if ( it != nameMap.end() ) { - ast::TypeInstType * mutType = ast::mutate( type ); - mutType->name = it->second; - type = mutType; + // unconditionally mutate because map will *always* have different name, + // if this mutates, will *always* have been mutated by ForallSubstitutor above + ast::TypeInstType * mut = ast::mutate( type ); + mut->name = it->second; + type = mut; } + return type; } @@ -88,29 +95,32 @@ template const NodeT * openLevel( const NodeT * type ) { - if ( !type->forall.empty() ) { - nameMap.beginScope(); - // Load new names from this forall clause and perform renaming. - NodeT * mutType = ast::mutate( type ); - for ( ast::ptr< ast::TypeDecl > & td : mutType->forall ) { - std::ostringstream output; - output << "_" << resetCount << "_" << level << "_" << td->name; - std::string newname( output.str() ); - nameMap[ td->name ] = newname; - ++level; + if ( type->forall.empty() ) return type; - ast::TypeDecl * decl = ast::mutate( td.get() ); - decl->name = newname; - td = decl; - } + nameMap.beginScope(); + + // Load new names from this forall clause and perform renaming. + NodeT * mutType = ast::mutate( type ); + assert( type == mutType && "mutated type must be unique from ForallSubstitutor" ); + for ( ast::ptr< ast::TypeDecl > & td : mutType->forall ) { + std::ostringstream output; + output << "_" << resetCount << "_" << level << "_" << td->name; + std::string newname = output.str(); + nameMap[ td->name ] = newname; + ++level; + + ast::TypeDecl * mutDecl = ast::mutate( td.get() ); + assert( td == mutDecl && "mutated decl must be unique from ForallSubstitutor" ); + mutDecl->name = newname; + // assertion above means `td = mutDecl;` is unnecessary } + // assertion above means `type = mutType;` is unnecessary + return type; } - template - const NodeT * closeLevel( const NodeT * type ) { - if ( !type->forall.empty() ) { - nameMap.endScope(); - } - return type; + void closeLevel( const ast::ParameterizedType * type ) { + if ( type->forall.empty() ) return; + + nameMap.endScope(); } }; @@ -119,5 +129,5 @@ RenamingData renaming; - struct RenameVars { + struct RenameVars_old { void previsit( TypeInstType * instType ) { renaming.openLevel( (Type*)instType ); @@ -130,4 +140,9 @@ renaming.closeLevel( type ); } + }; + + struct RenameVars_new /*: public ast::WithForallSubstitutor*/ { + #warning when old RenameVars goes away, replace hack below with global pass inheriting from WithForallSubstitutor + ast::ForallSubstitutionTable & subs = renaming.subs; const ast::FunctionType * previsit( const ast::FunctionType * type ) { @@ -146,6 +161,6 @@ return renaming.rename( renaming.openLevel( type ) ); } - const ast::ParameterizedType * postvisit( const ast::ParameterizedType * type ) { - return renaming.closeLevel( type ); + void postvisit( const ast::ParameterizedType * type ) { + renaming.closeLevel( type ); } }; @@ -154,11 +169,13 @@ void renameTyVars( Type * t ) { - PassVisitor renamer; + PassVisitor renamer; t->accept( renamer ); } const ast::Type * renameTyVars( const ast::Type * t ) { - ast::Pass renamer; - return t->accept( renamer ); + ast::Type *tc = ast::deepCopy(t); + ast::Pass renamer; +// return t->accept( renamer ); + return tc->accept( renamer ); } Index: src/ResolvExpr/ResolveTypeof.cc =================================================================== --- src/ResolvExpr/ResolveTypeof.cc (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/ResolvExpr/ResolveTypeof.cc (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -99,16 +99,16 @@ // replace basetypeof() by int if ( dynamic_cast(newType) ) { - Type* newerType = - new BasicType{ newType->get_qualifiers(), BasicType::SignedInt, + Type* newerType = + new BasicType{ newType->get_qualifiers(), BasicType::SignedInt, newType->attributes }; delete newType; newType = newerType; } - newType->get_qualifiers().val + newType->get_qualifiers().val = ( newType->get_qualifiers().val & ~Type::Qualifiers::Mask ) | oldQuals; } else { newType->get_qualifiers().val |= oldQuals; } - + return newType; } @@ -120,7 +120,7 @@ ResolveTypeof_new( const ast::SymbolTable & syms ) : localSymtab( syms ) {} - void premutate( const ast::TypeofType * ) { visit_children = false; } + void previsit( const ast::TypeofType * ) { visit_children = false; } - const ast::Type * postmutate( const ast::TypeofType * typeofType ) { + const ast::Type * postvisit( const ast::TypeofType * typeofType ) { // pass on null expression if ( ! typeofType->expr ) return typeofType; @@ -133,5 +133,5 @@ // typeof wrapping expression ast::TypeEnvironment dummy; - ast::ptr< ast::Expr > newExpr = + ast::ptr< ast::Expr > newExpr = resolveInVoidContext( typeofType->expr, localSymtab, dummy ); assert( newExpr->result && ! newExpr->result->isVoid() ); @@ -143,9 +143,9 @@ // replace basetypeof() by int if ( newType.as< ast::EnumInstType >() ) { - newType = new ast::BasicType{ + newType = new ast::BasicType{ ast::BasicType::SignedInt, newType->qualifiers, copy(newType->attributes) }; } - reset_qualifiers( - newType, + reset_qualifiers( + newType, ( newType->qualifiers & ~ast::CV::EquivQualifiers ) | typeofType->qualifiers ); } else { @@ -153,5 +153,5 @@ } - return newType; + return newType.release(); } }; Index: src/ResolvExpr/Resolver.cc =================================================================== --- src/ResolvExpr/Resolver.cc (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/ResolvExpr/Resolver.cc (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -982,5 +982,5 @@ ast::Pass finder; expr->accept( finder ); - return finder.pass.delExpr; + return finder.core.delExpr; } @@ -1072,7 +1072,7 @@ /// Strips extraneous casts out of an expression struct StripCasts_new final { - const ast::Expr * postmutate( const ast::CastExpr * castExpr ) { + const ast::Expr * postvisit( const ast::CastExpr * castExpr ) { if ( - castExpr->isGenerated + castExpr->isGenerated == ast::GeneratedCast && typesCompatible( castExpr->arg->result, castExpr->result ) ) { @@ -1128,5 +1128,5 @@ // set up and resolve expression cast to void - ast::CastExpr * untyped = new ast::CastExpr{ expr }; + ast::ptr< ast::CastExpr > untyped = new ast::CastExpr{ expr }; CandidateRef choice = findUnfinishedKindExpression( untyped, symtab, "", anyCandidate, ResolvMode::withAdjustment() ); @@ -1236,4 +1236,5 @@ public: + static size_t traceId; Resolver_new() = default; Resolver_new( const ast::SymbolTable & syms ) { symtab = syms; } @@ -1266,8 +1267,8 @@ const ast::ConstructorInit * previsit( const ast::ConstructorInit * ); }; - - void resolve( std::list< ast::ptr >& translationUnit ) { - ast::Pass< Resolver_new > resolver; - accept_all( translationUnit, resolver ); + // size_t Resolver_new::traceId = Stats::Heap::new_stacktrace_id("Resolver"); + + void resolve( std::list< ast::ptr< ast::Decl > >& translationUnit ) { + ast::Pass< Resolver_new >::run( translationUnit ); } @@ -1299,24 +1300,27 @@ // default value expressions have an environment which shouldn't be there and trips up // later passes. - ast::ptr< ast::FunctionDecl > ret = functionDecl; - for ( unsigned i = 0; i < functionDecl->type->params.size(); ++i ) { - const ast::ptr & d = functionDecl->type->params[i]; - - if ( const ast::ObjectDecl * obj = d.as< ast::ObjectDecl >() ) { + assert( functionDecl->unique() ); + ast::FunctionType * mutType = mutate( functionDecl->type.get() ); + + for ( unsigned i = 0 ; i < mutType->params.size() ; ++i ) { + if ( const ast::ObjectDecl * obj = mutType->params[i].as< ast::ObjectDecl >() ) { if ( const ast::SingleInit * init = obj->init.as< ast::SingleInit >() ) { if ( init->value->env == nullptr ) continue; // clone initializer minus the initializer environment - ast::chain_mutate( ret ) - ( &ast::FunctionDecl::type ) - ( &ast::FunctionType::params )[i] - ( &ast::ObjectDecl::init ) - ( &ast::SingleInit::value )->env = nullptr; - - assert( functionDecl != ret.get() || functionDecl->unique() ); - assert( ! ret->type->params[i].strict_as< ast::ObjectDecl >()->init.strict_as< ast::SingleInit >()->value->env ); + auto mutParam = mutate( mutType->params[i].strict_as< ast::ObjectDecl >() ); + auto mutInit = mutate( mutParam->init.strict_as< ast::SingleInit >() ); + auto mutValue = mutate( mutInit->value.get() ); + + mutValue->env = nullptr; + mutInit->value = mutValue; + mutParam->init = mutInit; + mutType->params[i] = mutParam; + + assert( ! mutType->params[i].strict_as< ast::ObjectDecl >()->init.strict_as< ast::SingleInit >()->value->env); } } } - return ret.get(); + mutate_field(functionDecl, &ast::FunctionDecl::type, mutType); + return functionDecl; } @@ -1341,5 +1345,5 @@ // in case we decide to allow nested enums GuardValue( inEnumDecl ); - inEnumDecl = false; + inEnumDecl = true; } Index: src/ResolvExpr/SatisfyAssertions.cpp =================================================================== --- src/ResolvExpr/SatisfyAssertions.cpp (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/ResolvExpr/SatisfyAssertions.cpp (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -9,7 +9,7 @@ // Author : Aaron B. Moss // Created On : Mon Jun 10 17:45:00 2019 -// Last Modified By : Aaron B. Moss -// Last Modified On : Mon Jun 10 17:45:00 2019 -// Update Count : 1 +// Last Modified By : Andrew Beach +// Last Modified On : Tue Oct 1 13:56:00 2019 +// Update Count : 2 // @@ -188,5 +188,5 @@ matches.emplace_back( - cdata, adjType, std::move( newEnv ), std::move( newNeed ), std::move( have ), + cdata, adjType, std::move( newEnv ), std::move( have ), std::move( newNeed ), std::move( newOpen ), crntResnSlot ); } @@ -229,15 +229,18 @@ InferMatcher( InferCache & inferred ) : inferred( inferred ) {} - const ast::Expr * postmutate( const ast::Expr * expr ) { + const ast::Expr * postvisit( const ast::Expr * expr ) { // Skip if no slots to find - if ( expr->inferred.mode != ast::Expr::InferUnion::Slots ) return expr; - + if ( !expr->inferred.hasSlots() ) return expr; + // if ( expr->inferred.mode != ast::Expr::InferUnion::Slots ) return expr; + std::vector missingSlots; // find inferred parameters for resolution slots - ast::InferredParams newInferred; + ast::InferredParams * newInferred = new ast::InferredParams(); for ( UniqueId slot : expr->inferred.resnSlots() ) { // fail if no matching assertions found auto it = inferred.find( slot ); if ( it == inferred.end() ) { - assert(!"missing assertion"); + std::cerr << "missing assertion " << slot << std::endl; + missingSlots.push_back(slot); + continue; } @@ -245,6 +248,6 @@ for ( auto & entry : it->second ) { // recurse on inferParams of resolved expressions - entry.second.expr = postmutate( entry.second.expr ); - auto res = newInferred.emplace( entry ); + entry.second.expr = postvisit( entry.second.expr ); + auto res = newInferred->emplace( entry ); assert( res.second && "all assertions newly placed" ); } @@ -252,5 +255,6 @@ ast::Expr * ret = mutate( expr ); - ret->inferred.set_inferParams( std::move( newInferred ) ); + ret->inferred.set_inferParams( newInferred ); + if (!missingSlots.empty()) ret->inferred.resnSlots() = missingSlots; return ret; } @@ -299,6 +303,6 @@ Cost cost; - OutType( - const ast::TypeEnvironment & e, const ast::OpenVarSet & o, + OutType( + const ast::TypeEnvironment & e, const ast::OpenVarSet & o, const std::vector< DeferRef > & as, const ast::SymbolTable & symtab ) : env( e ), open( o ), assns( as ), cost( Cost::zero ) { @@ -306,9 +310,9 @@ for ( const DeferRef & assn : assns ) { // compute conversion cost from satisfying decl to assertion - cost += computeConversionCost( - assn.match.adjType, assn.decl->get_type(), symtab, env ); - + cost += computeConversionCost( + assn.match.adjType, assn.decl->get_type(), false, symtab, env ); + // mark vars+specialization on function-type assertions - const ast::FunctionType * func = + const ast::FunctionType * func = GenPoly::getFunctionType( assn.match.cdata.id->get_type() ); if ( ! func ) continue; @@ -317,7 +321,7 @@ cost.decSpec( specCost( param->get_type() ) ); } - + cost.incVar( func->forall.size() ); - + for ( const ast::TypeDecl * td : func->forall ) { cost.decSpec( td->assertions.size() ); @@ -329,6 +333,6 @@ }; - CandidateEnvMerger( - const ast::TypeEnvironment & env, const ast::OpenVarSet & open, + CandidateEnvMerger( + const ast::TypeEnvironment & env, const ast::OpenVarSet & open, const ast::SymbolTable & syms ) : crnt(), envs{ env }, opens{ open }, symtab( syms ) {} Index: src/ResolvExpr/SatisfyAssertions.hpp =================================================================== --- src/ResolvExpr/SatisfyAssertions.hpp (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/ResolvExpr/SatisfyAssertions.hpp (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -28,6 +28,6 @@ /// Recursively satisfies all assertions provided in a candidate; returns true if succeeds -void satisfyAssertions( - CandidateRef & cand, const ast::SymbolTable & symtab, CandidateList & out, +void satisfyAssertions( + CandidateRef & cand, const ast::SymbolTable & symtab, CandidateList & out, std::vector & errors ); Index: src/ResolvExpr/SpecCost.cc =================================================================== --- src/ResolvExpr/SpecCost.cc (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/ResolvExpr/SpecCost.cc (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -10,8 +10,9 @@ // Created On : Tue Oct 02 15:50:00 2018 // Last Modified By : Andrew Beach -// Last Modified On : Wed Jun 19 10:43:00 2019 -// Update Count : 2 -// - +// Last Modified On : Wed Jul 3 11:07:00 2019 +// Update Count : 3 +// + +#include #include #include @@ -129,4 +130,12 @@ typename std::add_pointer::type; + #warning Should use a standard maybe_accept + void maybe_accept( ast::Type const * type ) { + if ( type ) { + auto node = type->accept( *visitor ); + assert( node == nullptr || node == type ); + } + } + // Update the minimum to the new lowest non-none value. template @@ -134,5 +143,5 @@ for ( const auto & node : list ) { count = -1; - mapper( node )->accept( *visitor ); + maybe_accept( mapper( node ) ); if ( count != -1 && count < minimum ) minimum = count; } @@ -208,6 +217,6 @@ } ast::Pass counter; - type->accept( *counter.pass.visitor ); - return counter.pass.get_count(); + type->accept( counter ); + return counter.core.get_count(); } Index: src/ResolvExpr/Unify.cc =================================================================== --- src/ResolvExpr/Unify.cc (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/ResolvExpr/Unify.cc (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -25,7 +25,9 @@ #include +#include "AST/Copy.hpp" #include "AST/Decl.hpp" #include "AST/Node.hpp" #include "AST/Pass.hpp" +#include "AST/Print.hpp" #include "AST/Type.hpp" #include "AST/TypeEnvironment.hpp" @@ -135,6 +137,5 @@ findOpenVars( newSecond, open, closed, need, have, FirstOpen ); - return unifyExact( - newFirst, newSecond, newEnv, need, have, open, noWiden(), symtab ); + return unifyExact(newFirst, newSecond, newEnv, need, have, open, noWiden(), symtab ); } @@ -148,13 +149,5 @@ newFirst->get_qualifiers() = Type::Qualifiers(); newSecond->get_qualifiers() = Type::Qualifiers(); -/// std::cerr << "first is "; -/// first->print( std::cerr ); -/// std::cerr << std::endl << "second is "; -/// second->print( std::cerr ); -/// std::cerr << std::endl << "newFirst is "; -/// newFirst->print( std::cerr ); -/// std::cerr << std::endl << "newSecond is "; -/// newSecond->print( std::cerr ); -/// std::cerr << std::endl; + bool result = unifyExact( newFirst, newSecond, newEnv, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer ); delete newFirst; @@ -170,12 +163,18 @@ ast::AssertionSet need, have; - ast::ptr newFirst{ first }, newSecond{ second }; - env.apply( newFirst ); - env.apply( newSecond ); - reset_qualifiers( newFirst ); - reset_qualifiers( newSecond ); + ast::Type * newFirst = shallowCopy( first ); + ast::Type * newSecond = shallowCopy( second ); + newFirst ->qualifiers = {}; + newSecond->qualifiers = {}; + ast::ptr< ast::Type > t1_(newFirst ); + ast::ptr< ast::Type > t2_(newSecond); + + ast::ptr< ast::Type > subFirst = env.apply(newFirst).node; + ast::ptr< ast::Type > subSecond = env.apply(newSecond).node; return unifyExact( - newFirst, newSecond, newEnv, need, have, open, noWiden(), symtab ); + subFirst, + subSecond, + newEnv, need, have, open, noWiden(), symtab ); } @@ -326,12 +325,6 @@ void markAssertionSet( AssertionSet &assertions, DeclarationWithType *assert ) { -/// std::cerr << "assertion set is" << std::endl; -/// printAssertionSet( assertions, std::cerr, 8 ); -/// std::cerr << "looking for "; -/// assert->print( std::cerr ); -/// std::cerr << std::endl; AssertionSet::iterator i = assertions.find( assert ); if ( i != assertions.end() ) { -/// std::cerr << "found it!" << std::endl; i->second.isUsed = true; } // if @@ -709,4 +702,5 @@ const ast::SymbolTable & symtab; public: + static size_t traceId; bool result; @@ -943,9 +937,11 @@ private: - template< typename RefType > - const RefType * handleRefType( const RefType * inst, const ast::Type * other ) { + // Returns: other, cast as XInstType + // Assigns this->result: whether types are compatible (up to generic parameters) + template< typename XInstType > + const XInstType * handleRefType( const XInstType * inst, const ast::Type * other ) { // check that the other type is compatible and named the same - auto otherInst = dynamic_cast< const RefType * >( other ); - result = otherInst && inst->name == otherInst->name; + auto otherInst = dynamic_cast< const XInstType * >( other ); + this->result = otherInst && inst->name == otherInst->name; return otherInst; } @@ -968,13 +964,13 @@ } - template< typename RefType > - void handleGenericRefType( const RefType * inst, const ast::Type * other ) { + template< typename XInstType > + void handleGenericRefType( const XInstType * inst, const ast::Type * other ) { // check that other type is compatible and named the same - const RefType * inst2 = handleRefType( inst, other ); - if ( ! inst2 ) return; + const XInstType * otherInst = handleRefType( inst, other ); + if ( ! this->result ) return; // check that parameters of types unify, if any const std::vector< ast::ptr< ast::Expr > > & params = inst->params; - const std::vector< ast::ptr< ast::Expr > > & params2 = inst2->params; + const std::vector< ast::ptr< ast::Expr > > & params2 = otherInst->params; auto it = params.begin(); @@ -1140,4 +1136,5 @@ }; + // size_t Unify_new::traceId = Stats::Heap::new_stacktrace_id("Unify_new"); bool unify( const ast::ptr & type1, const ast::ptr & type2, @@ -1188,5 +1185,5 @@ ast::Pass comparator{ type2, env, need, have, open, widen, symtab }; type1->accept( comparator ); - return comparator.pass.result; + return comparator.core.result; } } @@ -1202,15 +1199,16 @@ // force t1 and t2 to be cloned if their qualifiers must be stripped, so that type1 and // type2 are left unchanged; calling convention forces type{1,2}->strong_ref >= 1 - ast::ptr t1{ type1 }, t2{ type2 }; - reset_qualifiers( t1 ); - reset_qualifiers( t2 ); + ast::Type * t1 = shallowCopy(type1.get()); + ast::Type * t2 = shallowCopy(type2.get()); + t1->qualifiers = {}; + t2->qualifiers = {}; + ast::ptr< ast::Type > t1_(t1); + ast::ptr< ast::Type > t2_(t2); if ( unifyExact( t1, t2, env, need, have, open, widen, symtab ) ) { - t1 = nullptr; t2 = nullptr; // release t1, t2 to avoid spurious clones - // if exact unification on unqualified types, try to merge qualifiers if ( q1 == q2 || ( ( q1 > q2 || widen.first ) && ( q2 > q1 || widen.second ) ) ) { - common = type1; - reset_qualifiers( common, q1 | q2 ); + t1->qualifiers = q1 | q2; + common = t1; return true; } else { @@ -1219,8 +1217,8 @@ } else if (( common = commonType( t1, t2, widen, symtab, env, open ) )) { - t1 = nullptr; t2 = nullptr; // release t1, t2 to avoid spurious clones - // no exact unification, but common type - reset_qualifiers( common, q1 | q2 ); + auto c = shallowCopy(common.get()); + c->qualifiers = q1 | q2; + common = c; return true; } else { Index: src/ResolvExpr/typeops.h =================================================================== --- src/ResolvExpr/typeops.h (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/ResolvExpr/typeops.h (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -10,6 +10,6 @@ // Created On : Sun May 17 07:28:22 2015 // Last Modified By : Andrew Beach -// Last Modified On : Thu Aug 8 16:36:00 2019 -// Update Count : 5 +// Last Modified On : Tue Oct 1 09:45:00 2019 +// Update Count : 6 // @@ -83,6 +83,6 @@ const SymTab::Indexer & indexer, const TypeEnvironment & env ); Cost castCost( - const ast::Type * src, const ast::Type * dst, const ast::SymbolTable & symtab, - const ast::TypeEnvironment & env ); + const ast::Type * src, const ast::Type * dst, bool srcIsLvalue, + const ast::SymbolTable & symtab, const ast::TypeEnvironment & env ); // in ConversionCost.cc @@ -90,6 +90,6 @@ const SymTab::Indexer & indexer, const TypeEnvironment & env ); Cost conversionCost( - const ast::Type * src, const ast::Type * dst, const ast::SymbolTable & symtab, - const ast::TypeEnvironment & env ); + const ast::Type * src, const ast::Type * dst, bool srcIsLvalue, + const ast::SymbolTable & symtab, const ast::TypeEnvironment & env ); // in AlternativeFinder.cc Index: src/SymTab/Autogen.h =================================================================== --- src/SymTab/Autogen.h (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/SymTab/Autogen.h (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -21,4 +21,5 @@ #include "AST/Decl.hpp" +#include "AST/Eval.hpp" #include "AST/Expr.hpp" #include "AST/Init.hpp" @@ -265,5 +266,6 @@ } - ast::ptr< ast::Expr > begin, end, cmp, update; + ast::ptr< ast::Expr > begin, end; + std::string cmp, update; if ( forward ) { @@ -271,14 +273,13 @@ begin = ast::ConstantExpr::from_int( loc, 0 ); end = array->dimension; - cmp = new ast::NameExpr{ loc, "?= 0; --i ) - begin = new ast::UntypedExpr{ - loc, new ast::NameExpr{ loc, "?-?" }, - { array->dimension, ast::ConstantExpr::from_int( loc, 1 ) } }; + begin = ast::call( + loc, "?-?", array->dimension, ast::ConstantExpr::from_int( loc, 1 ) ); end = ast::ConstantExpr::from_int( loc, 0 ); - cmp = new ast::NameExpr{ loc, "?>=?" }; - update = new ast::NameExpr{ loc, "--?" }; + cmp = "?>=?"; + update = "--?"; } @@ -286,18 +287,15 @@ loc, indexName.newName(), new ast::BasicType{ ast::BasicType::SignedInt }, new ast::SingleInit{ loc, begin } }; - - ast::ptr< ast::Expr > cond = new ast::UntypedExpr{ - loc, cmp, { new ast::VariableExpr{ loc, index }, end } }; - - ast::ptr< ast::Expr > inc = new ast::UntypedExpr{ - loc, update, { new ast::VariableExpr{ loc, index } } }; - - ast::ptr< ast::Expr > dstIndex = new ast::UntypedExpr{ - loc, new ast::NameExpr{ loc, "?[?]" }, - { dstParam, new ast::VariableExpr{ loc, index } } }; + ast::ptr< ast::Expr > indexVar = new ast::VariableExpr{ loc, index }; + + ast::ptr< ast::Expr > cond = ast::call( loc, cmp, indexVar, end ); + + ast::ptr< ast::Expr > inc = ast::call( loc, update, indexVar ); + + ast::ptr< ast::Expr > dstIndex = ast::call( loc, "?[?]", dstParam, indexVar ); // srcParam must keep track of the array indices to build the source parameter and/or // array list initializer - srcParam.addArrayIndex( new ast::VariableExpr{ loc, index }, array->dimension ); + srcParam.addArrayIndex( indexVar, array->dimension ); // for stmt's body, eventually containing call @@ -385,5 +383,5 @@ if ( isUnnamedBitfield( obj ) ) return {}; - ast::ptr< ast::Type > addCast = nullptr; + ast::ptr< ast::Type > addCast; if ( (fname == "?{}" || fname == "^?{}") && ( ! obj || ( obj && ! obj->bitfieldWidth ) ) ) { assert( dstParam->result ); Index: src/SymTab/FixFunction.cc =================================================================== --- src/SymTab/FixFunction.cc (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/SymTab/FixFunction.cc (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -106,7 +106,7 @@ bool isVoid = false; - void premutate( const ast::FunctionDecl * ) { visit_children = false; } + void previsit( const ast::FunctionDecl * ) { visit_children = false; } - const ast::DeclWithType * postmutate( const ast::FunctionDecl * func ) { + const ast::DeclWithType * postvisit( const ast::FunctionDecl * func ) { return new ast::ObjectDecl{ func->location, func->name, new ast::PointerType{ func->type }, nullptr, @@ -114,7 +114,7 @@ } - void premutate( const ast::ArrayType * ) { visit_children = false; } + void previsit( const ast::ArrayType * ) { visit_children = false; } - const ast::Type * postmutate( const ast::ArrayType * array ) { + const ast::Type * postvisit( const ast::ArrayType * array ) { return new ast::PointerType{ array->base, array->dimension, array->isVarLen, array->isStatic, @@ -122,17 +122,17 @@ } - void premutate( const ast::VoidType * ) { isVoid = true; } + void previsit( const ast::VoidType * ) { isVoid = true; } - void premutate( const ast::BasicType * ) { visit_children = false; } - void premutate( const ast::PointerType * ) { visit_children = false; } - void premutate( const ast::StructInstType * ) { visit_children = false; } - void premutate( const ast::UnionInstType * ) { visit_children = false; } - void premutate( const ast::EnumInstType * ) { visit_children = false; } - void premutate( const ast::TraitInstType * ) { visit_children = false; } - void premutate( const ast::TypeInstType * ) { visit_children = false; } - void premutate( const ast::TupleType * ) { visit_children = false; } - void premutate( const ast::VarArgsType * ) { visit_children = false; } - void premutate( const ast::ZeroType * ) { visit_children = false; } - void premutate( const ast::OneType * ) { visit_children = false; } + void previsit( const ast::BasicType * ) { visit_children = false; } + void previsit( const ast::PointerType * ) { visit_children = false; } + void previsit( const ast::StructInstType * ) { visit_children = false; } + void previsit( const ast::UnionInstType * ) { visit_children = false; } + void previsit( const ast::EnumInstType * ) { visit_children = false; } + void previsit( const ast::TraitInstType * ) { visit_children = false; } + void previsit( const ast::TypeInstType * ) { visit_children = false; } + void previsit( const ast::TupleType * ) { visit_children = false; } + void previsit( const ast::VarArgsType * ) { visit_children = false; } + void previsit( const ast::ZeroType * ) { visit_children = false; } + void previsit( const ast::OneType * ) { visit_children = false; } }; } // anonymous namespace @@ -141,5 +141,5 @@ ast::Pass< FixFunction_new > fixer; dwt = dwt->accept( fixer ); - isVoid |= fixer.pass.isVoid; + isVoid |= fixer.core.isVoid; return dwt; } Index: src/SymTab/Mangler.cc =================================================================== --- src/SymTab/Mangler.cc (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/SymTab/Mangler.cc (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -447,5 +447,5 @@ ast::Pass mangler( mode ); maybeAccept( decl, mangler ); - return mangler.pass.get_mangleName(); + return mangler.core.get_mangleName(); } @@ -691,5 +691,5 @@ mangleOverridable, typeMode, mangleGenericParams, nextVarNum, varNums ); assert->accept( sub_mangler ); - assertionNames.push_back( sub_mangler.pass.get_mangleName() ); + assertionNames.push_back( sub_mangler.core.get_mangleName() ); acount++; } // for Index: src/SynTree/ApplicationExpr.cc =================================================================== --- src/SynTree/ApplicationExpr.cc (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/SynTree/ApplicationExpr.cc (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -34,9 +34,9 @@ ParamEntry::ParamEntry( const ParamEntry &other ) : - decl( other.decl ), declptr( maybeClone( other.declptr ) ), actualType( maybeClone( other.actualType ) ), formalType( maybeClone( other.formalType ) ), expr( maybeClone( other.expr ) ) { + decl( other.decl ), declptr( other.declptr ), actualType( maybeClone( other.actualType ) ), formalType( maybeClone( other.formalType ) ), expr( maybeClone( other.expr ) ) { } ParamEntry::~ParamEntry() { - delete declptr; + // delete declptr; delete actualType; delete formalType; Index: src/SynTree/Statement.h =================================================================== --- src/SynTree/Statement.h (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/SynTree/Statement.h (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -518,5 +518,5 @@ class ImplicitCtorDtorStmt : public Statement { public: - // Non-owned pointer to the constructor/destructor statement + // the constructor/destructor call statement; owned here for a while, eventually transferred elsewhere Statement * callStmt; Index: src/Tuples/Explode.cc =================================================================== --- src/Tuples/Explode.cc (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/Tuples/Explode.cc (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -129,5 +129,4 @@ for ( const ast::Expr * expr : tupleExpr->exprs ) { exprs.emplace_back( applyCast( expr, false ) ); - //exprs.emplace_back( ast::ptr< ast::Expr >( applyCast( expr, false ) ) ); } if ( first ) { @@ -148,5 +147,5 @@ } - const ast::Expr * postmutate( const ast::UniqueExpr * node ) { + const ast::Expr * postvisit( const ast::UniqueExpr * node ) { // move cast into unique expr so that the unique expr has type T& rather than // type T. In particular, this transformation helps with generating the @@ -167,5 +166,5 @@ } - const ast::Expr * postmutate( const ast::TupleIndexExpr * tupleExpr ) { + const ast::Expr * postvisit( const ast::TupleIndexExpr * tupleExpr ) { // tuple index expr needs to be rebuilt to ensure that the type of the // field is consistent with the type of the tuple expr, since the field @@ -180,5 +179,5 @@ ast::Pass exploder; expr = expr->accept( exploder ); - if ( ! exploder.pass.foundUniqueExpr ) { + if ( ! exploder.core.foundUniqueExpr ) { expr = new ast::CastExpr{ expr, new ast::ReferenceType{ expr->result } }; } Index: src/Tuples/Explode.h =================================================================== --- src/Tuples/Explode.h (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/Tuples/Explode.h (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -210,5 +210,5 @@ } // Cast a reference away to a value-type to allow further explosion. - if ( dynamic_cast< const ast::ReferenceType *>( local->result.get() ) ) { + if ( local->result.as< ast::ReferenceType >() ) { local = new ast::CastExpr{ local, tupleType }; } @@ -220,5 +220,4 @@ // delete idx; } - // delete local; } } else { Index: src/Tuples/TupleAssignment.cc =================================================================== --- src/Tuples/TupleAssignment.cc (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/Tuples/TupleAssignment.cc (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -465,5 +465,5 @@ // resolve ctor/dtor for the new object ast::ptr< ast::Init > ctorInit = ResolvExpr::resolveCtorInit( - InitTweak::genCtorInit( location, ret ), spotter.crntFinder.symtab ); + InitTweak::genCtorInit( location, ret ), spotter.crntFinder.localSyms ); // remove environments from subexpressions of stmtExpr ast::Pass< EnvRemover > rm{ env }; @@ -504,6 +504,7 @@ std::vector< ast::ptr< ast::Expr > > match() override { - static UniqueName lhsNamer( "__massassign_L" ); - static UniqueName rhsNamer( "__massassign_R" ); + // temporary workaround for new and old ast to coexist and avoid name collision + static UniqueName lhsNamer( "__massassign_Ln" ); + static UniqueName rhsNamer( "__massassign_Rn" ); // empty tuple case falls into this matcher assert( lhs.empty() ? rhs.empty() : rhs.size() <= 1 ); @@ -534,6 +535,7 @@ std::vector< ast::ptr< ast::Expr > > match() override { - static UniqueName lhsNamer( "__multassign_L" ); - static UniqueName rhsNamer( "__multassign_R" ); + // temporary workaround for new and old ast to coexist and avoid name collision + static UniqueName lhsNamer( "__multassign_Ln" ); + static UniqueName rhsNamer( "__multassign_Rn" ); if ( lhs.size() != rhs.size() ) return {}; @@ -560,5 +562,5 @@ // resolve the cast expression so that rhsCand return type is bound by the cast // type as needed, and transfer the resulting environment - ResolvExpr::CandidateFinder finder{ spotter.crntFinder.symtab, env }; + ResolvExpr::CandidateFinder finder{ spotter.crntFinder.localSyms, env }; finder.find( rhsCand->expr, ResolvExpr::ResolvMode::withAdjustment() ); assert( finder.candidates.size() == 1 ); @@ -609,5 +611,5 @@ // explode the LHS so that each field of a tuple-valued expr is assigned ResolvExpr::CandidateList lhs; - explode( *lhsCand, crntFinder.symtab, back_inserter(lhs), true ); + explode( *lhsCand, crntFinder.localSyms, back_inserter(lhs), true ); for ( ResolvExpr::CandidateRef & cand : lhs ) { // each LHS value must be a reference - some come in with a cast, if not @@ -629,5 +631,5 @@ if ( isTuple( rhsCand->expr ) ) { // multiple assignment - explode( *rhsCand, crntFinder.symtab, back_inserter(rhs), true ); + explode( *rhsCand, crntFinder.localSyms, back_inserter(rhs), true ); matcher.reset( new MultipleAssignMatcher{ *this, expr->location, lhs, rhs } ); @@ -648,5 +650,5 @@ // multiple assignment ResolvExpr::CandidateList rhs; - explode( rhsCand, crntFinder.symtab, back_inserter(rhs), true ); + explode( rhsCand, crntFinder.localSyms, back_inserter(rhs), true ); matcher.reset( new MultipleAssignMatcher{ *this, expr->location, lhs, rhs } ); @@ -678,5 +680,5 @@ ) - ResolvExpr::CandidateFinder finder{ crntFinder.symtab, matcher->env }; + ResolvExpr::CandidateFinder finder{ crntFinder.localSyms, matcher->env }; try { Index: src/Tuples/TupleExpansion.cc =================================================================== --- src/Tuples/TupleExpansion.cc (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/Tuples/TupleExpansion.cc (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -323,5 +323,5 @@ std::vector> types; ast::CV::Qualifiers quals{ - ast::CV::Const | ast::CV::Volatile | ast::CV::Restrict | ast::CV::Lvalue | + ast::CV::Const | ast::CV::Volatile | ast::CV::Restrict | ast::CV::Atomic | ast::CV::Mutex }; Index: src/Tuples/Tuples.cc =================================================================== --- src/Tuples/Tuples.cc (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/Tuples/Tuples.cc (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -43,4 +43,5 @@ }; struct ImpurityDetectorIgnoreUnique : public ImpurityDetector { + using ImpurityDetector::previsit; void previsit( ast::UniqueExpr const * ) { visit_children = false; @@ -52,5 +53,5 @@ ast::Pass detector; expr->accept( detector ); - return detector.pass.maybeImpure; + return detector.core.maybeImpure; } } // namespace Index: src/config.h.in =================================================================== --- src/config.h.in (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/config.h.in (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -27,4 +27,8 @@ /* Location of cfa install. */ #undef CFA_PREFIX + +/* Sets whether or not to use the new-ast, this is adefault value and can be + overrided by --old-ast and --new-ast */ +#undef CFA_USE_NEW_AST /* Major.Minor */ Index: src/main.cc =================================================================== --- src/main.cc (revision 309d8141747e741a9d445f6a58c51aa1b19eead4) +++ src/main.cc (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -31,5 +31,5 @@ using namespace std; - +#include "AST/Convert.hpp" #include "CompilationState.h" #include "../config.h" // for CFA_LIBDIR @@ -340,5 +340,12 @@ } // if - PASS( "Resolve", ResolvExpr::resolve( translationUnit ) ); + if( useNewAST) { + auto transUnit = convert( move( translationUnit ) ); + PASS( "Resolve", ResolvExpr::resolve( transUnit ) ); + translationUnit = convert( move( transUnit ) ); + } else { + PASS( "Resolve", ResolvExpr::resolve( translationUnit ) ); + } + if ( exprp ) { dump( translationUnit ); @@ -458,4 +465,6 @@ { "prototypes", no_argument, nullptr, 'p' }, { "deterministic-out", no_argument, nullptr, 'd' }, + { "old-ast", no_argument, nullptr, 'O'}, + { "new-ast", no_argument, nullptr, 'A'}, { "print", required_argument, nullptr, 'P' }, { "prelude-dir", required_argument, nullptr, PreludeDir }, @@ -479,4 +488,6 @@ "generate prototypes for prelude functions", // -p "don't print output that isn't deterministic", // -d + "Use the old-ast", // -O + "Use the new-ast", // -A "print", // -P " prelude directory for debug/nodebug", // no flag @@ -584,5 +595,11 @@ break; case 'd': // don't print non-deterministic output - deterministic_output = true; + deterministic_output = true; + break; + case 'O': // don't print non-deterministic output + useNewAST = false; + break; + case 'A': // don't print non-deterministic output + useNewAST = true; break; case 'P': // print options Index: tests/exceptions/.expect/trash.txt =================================================================== --- tests/exceptions/.expect/trash.txt (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) +++ tests/exceptions/.expect/trash.txt (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -0,0 +1,2 @@ +inner yang +outer yin Index: tests/exceptions/trash.cfa =================================================================== --- tests/exceptions/trash.cfa (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) +++ tests/exceptions/trash.cfa (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -0,0 +1,27 @@ +// Make sure throw-catch during unwind does not trash internal data. + +#include +#include + +TRIVIAL_EXCEPTION(yin); +TRIVIAL_EXCEPTION(yang); + +int main(int argc, char * argv[]) { + try { + try { + throw (yin){}; + } finally { + try { + throw (yang){}; + } catch (yin *) { + printf("inner yin\n"); + } catch (yang *) { + printf("inner yang\n"); + } + } + } catch (yin *) { + printf("outer yin\n"); + } catch (yang *) { + printf("outer yang\n"); + } +} Index: tests/resolutionErrors.cfa =================================================================== --- tests/resolutionErrors.cfa (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) +++ tests/resolutionErrors.cfa (revision 4c925cd31e0a0d5ba86584befde68164c77404b8) @@ -0,0 +1,47 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// resolutionErrors.cfa -- +// +// Author : Thierry Delisle +// Created On : Thu Nov 28 15:17:52 2019 +// Last Modified By : +// Last Modified On : +// Update Count : +// + +struct atype {}; + +void noparams() {} +void wrongparams( atype& ) {} +void moreparams( int, int ) {} +void fewparams( int ) {} +void noreturn() {} + +void simple_calls() { + notexist(); + notexistparams( 3 ); + noparams( 3 ); + wrongparams( 3 ); + moreparams( 3 ); + fewparams( 3, 3 ); + int a = noreturn(); + + int notfunction; + notfunction(3); + + atype t; + t.a; +} + +void ctor_calls() { + atype a = 3; +} + +// Local Variables: // +// tab-width: 4 // +// compile-command: "cfa resolutionErrors.cfa" // +// End: //