source: src/SymTab/Indexer.cc@ 361bf01

ADT arm-eh ast-experimental enum forall-pointer-decay jacob/cs343-translation new-ast-unique-expr pthread-emulation qualifiedEnum
Last change on this file since 361bf01 was 07de76b, checked in by Peter A. Buhr <pabuhr@…>, 6 years ago

remove file TypeVar.h* and put TypeVar::Kind into TypeDecl, move LinkageSpec.* from directory Parse to SynTree
  • Property mode set to 100644
File size: 24.6 KB
Line 
1//
2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
3//
4// The contents of this file are covered under the licence agreement in the
5// file "LICENCE" distributed with Cforall.
6//
7// Indexer.cc --
8//
9// Author : Richard C. Bilson
10// Created On : Sun May 17 21:37:33 2015
11// Last Modified By : Peter A. Buhr
12// Last Modified On : Fri Dec 13 23:43:19 2019
13// Update Count : 22
14//
15
16#include "Indexer.h"
17
18#include <cassert> // for assert, strict_dynamic_cast
19#include <string> // for string, operator<<, operator!=
20#include <memory> // for shared_ptr, make_shared
21#include <unordered_map> // for operator!=, unordered_map<>::const...
22#include <unordered_set> // for unordered_set
23#include <utility> // for pair, make_pair, move
24#include <vector> // for vector
25
26#include "CodeGen/OperatorTable.h" // for isCtorDtor, isCtorDtorAssign
27#include "Common/SemanticError.h" // for SemanticError
28#include "Common/utility.h" // for cloneAll
29#include "Common/Stats/Counter.h" // for counters
30#include "GenPoly/GenPoly.h" // for getFunctionType
31#include "InitTweak/InitTweak.h" // for isConstructor, isCopyFunction, isC...
32#include "Mangler.h" // for Mangler
33#include "ResolvExpr/typeops.h" // for typesCompatible
34#include "SynTree/LinkageSpec.h" // for isMangled, isOverridable, Spec
35#include "SynTree/Constant.h" // for Constant
36#include "SynTree/Declaration.h" // for DeclarationWithType, FunctionDecl
37#include "SynTree/Expression.h" // for Expression, ImplicitCopyCtorExpr
38#include "SynTree/Initializer.h" // for Initializer
39#include "SynTree/Statement.h" // for CompoundStmt, Statement, ForStmt (...
40#include "SynTree/Type.h" // for Type, StructInstType, UnionInstType
41
42namespace SymTab {
43
44 // Statistics block
45 namespace {
46 static inline auto stats() {
47 using namespace Stats::Counters;
48 static auto group = build<CounterGroup>("Indexers");
49 static struct {
50 SimpleCounter * count;
51 AverageCounter<double> * size;
52 SimpleCounter * new_scopes;
53 SimpleCounter * lazy_scopes;
54 AverageCounter<double> * avg_scope_depth;
55 MaxCounter<size_t> * max_scope_depth;
56 SimpleCounter * add_calls;
57 SimpleCounter * lookup_calls;
58 SimpleCounter * map_lookups;
59 SimpleCounter * map_mutations;
60 } ret = {
61 .count = build<SimpleCounter>("Count", group),
62 .size = build<AverageCounter<double>>("Average Size", group),
63 .new_scopes = build<SimpleCounter>("Scopes", group),
64 .lazy_scopes = build<SimpleCounter>("Lazy Scopes", group),
65 .avg_scope_depth = build<AverageCounter<double>>("Average Scope", group),
66 .max_scope_depth = build<MaxCounter<size_t>>("Max Scope", group),
67 .add_calls = build<SimpleCounter>("Add Calls", group),
68 .lookup_calls = build<SimpleCounter>("Lookup Calls", group),
69 .map_lookups = build<SimpleCounter>("Map Lookups", group),
70 .map_mutations = build<SimpleCounter>("Map Mutations", group)
71 };
72 return ret;
73 }
74 }
75
76 Indexer::Indexer()
77 : idTable(), typeTable(), structTable(), enumTable(), unionTable(), traitTable(),
78 prevScope(), scope( 0 ), repScope( 0 ) { ++* stats().count; }
79
80 Indexer::~Indexer() {
81 stats().size->push( idTable ? idTable->size() : 0 );
82 }
83
84 void Indexer::lazyInitScope() {
85 if ( repScope < scope ) {
86 ++* stats().lazy_scopes;
87 // create rollback
88 prevScope = std::make_shared<Indexer>( * this );
89 // update repScope
90 repScope = scope;
91 }
92 }
93
94 void Indexer::enterScope() {
95 ++scope;
96
97 ++* stats().new_scopes;
98 stats().avg_scope_depth->push( scope );
99 stats().max_scope_depth->push( scope );
100 }
101
102 void Indexer::leaveScope() {
103 if ( repScope == scope ) {
104 Ptr prev = prevScope; // make sure prevScope stays live
105 * this = std::move(* prevScope); // replace with previous scope
106 }
107
108 --scope;
109 }
110
111 void Indexer::lookupId( const std::string & id, std::list< IdData > &out ) const {
112 ++* stats().lookup_calls;
113 if ( ! idTable ) return;
114
115 ++* stats().map_lookups;
116 auto decls = idTable->find( id );
117 if ( decls == idTable->end() ) return;
118
119 for ( auto decl : *(decls->second) ) {
120 out.push_back( decl.second );
121 }
122 }
123
124 const NamedTypeDecl * Indexer::lookupType( const std::string & id ) const {
125 ++* stats().lookup_calls;
126 if ( ! typeTable ) return nullptr;
127 ++* stats().map_lookups;
128 auto it = typeTable->find( id );
129 return it == typeTable->end() ? nullptr : it->second.decl;
130 }
131
132 const StructDecl * Indexer::lookupStruct( const std::string & id ) const {
133 ++* stats().lookup_calls;
134 if ( ! structTable ) return nullptr;
135 ++* stats().map_lookups;
136 auto it = structTable->find( id );
137 return it == structTable->end() ? nullptr : it->second.decl;
138 }
139
140 const EnumDecl * Indexer::lookupEnum( const std::string & id ) const {
141 ++* stats().lookup_calls;
142 if ( ! enumTable ) return nullptr;
143 ++* stats().map_lookups;
144 auto it = enumTable->find( id );
145 return it == enumTable->end() ? nullptr : it->second.decl;
146 }
147
148 const UnionDecl * Indexer::lookupUnion( const std::string & id ) const {
149 ++* stats().lookup_calls;
150 if ( ! unionTable ) return nullptr;
151 ++* stats().map_lookups;
152 auto it = unionTable->find( id );
153 return it == unionTable->end() ? nullptr : it->second.decl;
154 }
155
156 const TraitDecl * Indexer::lookupTrait( const std::string & id ) const {
157 ++* stats().lookup_calls;
158 if ( ! traitTable ) return nullptr;
159 ++* stats().map_lookups;
160 auto it = traitTable->find( id );
161 return it == traitTable->end() ? nullptr : it->second.decl;
162 }
163
164 const Indexer * Indexer::atScope( unsigned long target ) const {
165 // by lazy construction, final indexer in list has repScope 0, cannot be > target
166 // otherwise, will find first scope representing the target
167 const Indexer * indexer = this;
168 while ( indexer->repScope > target ) {
169 indexer = indexer->prevScope.get();
170 }
171 return indexer;
172 }
173
174 const NamedTypeDecl * Indexer::globalLookupType( const std::string & id ) const {
175 return atScope( 0 )->lookupType( id );
176 }
177
178 const StructDecl * Indexer::globalLookupStruct( const std::string & id ) const {
179 return atScope( 0 )->lookupStruct( id );
180 }
181
182 const UnionDecl * Indexer::globalLookupUnion( const std::string & id ) const {
183 return atScope( 0 )->lookupUnion( id );
184 }
185
186 const EnumDecl * Indexer::globalLookupEnum( const std::string & id ) const {
187 return atScope( 0 )->lookupEnum( id );
188 }
189
190 bool isFunction( const DeclarationWithType * decl ) {
191 return GenPoly::getFunctionType( decl->get_type() );
192 }
193
194 bool isObject( const DeclarationWithType * decl ) {
195 return ! isFunction( decl );
196 }
197
198 bool isDefinition( const DeclarationWithType * decl ) {
199 if ( const FunctionDecl * func = dynamic_cast< const FunctionDecl * >( decl ) ) {
200 // a function is a definition if it has a body
201 return func->statements;
202 } else {
203 // an object is a definition if it is not marked extern.
204 // both objects must be marked extern
205 return ! decl->get_storageClasses().is_extern;
206 }
207 }
208
209
210 bool Indexer::addedIdConflicts(
211 const Indexer::IdData & existing, const DeclarationWithType * added,
212 Indexer::OnConflict handleConflicts, const Declaration * deleteStmt ) {
213 // if we're giving the same name mangling to things of different types then there is
214 // something wrong
215 assert( (isObject( added ) && isObject( existing.id ) )
216 || ( isFunction( added ) && isFunction( existing.id ) ) );
217
218 if ( LinkageSpec::isOverridable( existing.id->linkage ) ) {
219 // new definition shadows the autogenerated one, even at the same scope
220 return false;
221 } else if ( LinkageSpec::isMangled( added->linkage )
222 || ResolvExpr::typesCompatible(
223 added->get_type(), existing.id->get_type(), Indexer() ) ) {
224
225 // it is a conflict if one declaration is deleted and the other is not
226 if ( deleteStmt && ! existing.deleteStmt ) {
227 if ( handleConflicts.mode == OnConflict::Error ) {
228 SemanticError( added, "deletion of defined identifier " );
229 }
230 return true;
231 } else if ( ! deleteStmt && existing.deleteStmt ) {
232 if ( handleConflicts.mode == OnConflict::Error ) {
233 SemanticError( added, "definition of deleted identifier " );
234 }
235 return true;
236 }
237
238 if ( isDefinition( added ) && isDefinition( existing.id ) ) {
239 if ( handleConflicts.mode == OnConflict::Error ) {
240 SemanticError( added,
241 isFunction( added ) ?
242 "duplicate function definition for " :
243 "duplicate object definition for " );
244 }
245 return true;
246 } // if
247 } else {
248 if ( handleConflicts.mode == OnConflict::Error ) {
249 SemanticError( added, "duplicate definition for " );
250 }
251 return true;
252 } // if
253
254 return true;
255 }
256
257 bool Indexer::hasCompatibleCDecl( const std::string & id, const std::string &mangleName ) const {
258 if ( ! idTable ) return false;
259
260 ++* stats().map_lookups;
261 auto decls = idTable->find( id );
262 if ( decls == idTable->end() ) return false;
263
264 for ( auto decl : *(decls->second) ) {
265 // skip other scopes (hidden by this decl)
266 if ( decl.second.scope != scope ) continue;
267 // check for C decl with compatible type (by mangleName)
268 if ( ! LinkageSpec::isMangled( decl.second.id->linkage ) && decl.first == mangleName ) {
269 return true;
270 }
271 }
272
273 return false;
274 }
275
276 bool Indexer::hasIncompatibleCDecl(const std::string & id, const std::string &mangleName ) const {
277 if ( ! idTable ) return false;
278
279 ++* stats().map_lookups;
280 auto decls = idTable->find( id );
281 if ( decls == idTable->end() ) return false;
282
283 for ( auto decl : *(decls->second) ) {
284 // skip other scopes (hidden by this decl)
285 if ( decl.second.scope != scope ) continue;
286 // check for C decl with incompatible type (by manglename)
287 if ( ! LinkageSpec::isMangled( decl.second.id->linkage ) && decl.first != mangleName ) {
288 return true;
289 }
290 }
291
292 return false;
293 }
294
295 /// gets the base type of the first parameter; decl must be a ctor/dtor/assignment function
296 std::string getOtypeKey( const FunctionDecl * function ) {
297 auto& params = function->type->parameters;
298 assert( ! params.empty() );
299 // use base type of pointer, so that qualifiers on the pointer type aren't considered.
300 Type * base = InitTweak::getPointerBase( params.front()->get_type() );
301 assert( base );
302 return Mangler::mangle( base );
303 }
304
305 /// gets the declaration for the function acting on a type specified by otype key,
306 /// nullptr if none such
307 const FunctionDecl * getFunctionForOtype( const DeclarationWithType * decl, const std::string& otypeKey ) {
308 const FunctionDecl * func = dynamic_cast< const FunctionDecl * >( decl );
309 if ( ! func || otypeKey != getOtypeKey( func ) ) return nullptr;
310 return func;
311 }
312
313 bool Indexer::removeSpecialOverrides(Indexer::IdData& data, Indexer::MangleTable::Ptr& mangleTable ) {
314 // if a type contains user defined ctor/dtor/assign, then special rules trigger, which
315 // determinethe set of ctor/dtor/assign that can be used by the requester. In particular,
316 // if the user defines a default ctor, then the generated default ctor is unavailable,
317 // likewise for copy ctor and dtor. If the user defines any ctor/dtor, then no generated
318 // field ctors are available. If the user defines any ctor then the generated default ctor
319 // is unavailable (intrinsic default ctor must be overridden exactly). If the user defines
320 // anything that looks like a copy constructor, then the generated copy constructor is
321 // unavailable, and likewise for the assignment operator.
322
323 // only relevant on function declarations
324 const FunctionDecl * function = dynamic_cast< const FunctionDecl * >( data.id );
325 if ( ! function ) return true;
326 // only need to perform this check for constructors, destructors, and assignment functions
327 if ( ! CodeGen::isCtorDtorAssign( data.id->name ) ) return true;
328
329 // set up information for this type
330 bool dataIsUserDefinedFunc = ! LinkageSpec::isOverridable( function->linkage );
331 bool dataIsCopyFunc = InitTweak::isCopyFunction( function, function->name );
332 std::string dataOtypeKey = getOtypeKey( function );
333
334 if ( dataIsUserDefinedFunc && dataIsCopyFunc ) {
335 // this is a user-defined copy function
336 // if this is the first such, delete/remove non-user-defined overloads as needed
337 std::vector< std::string > removed;
338 std::vector< MangleTable::value_type > deleted;
339 bool alreadyUserDefinedFunc = false;
340
341 for ( const auto& entry : * mangleTable ) {
342 // skip decls that aren't functions or are for the wrong type
343 const FunctionDecl * decl = getFunctionForOtype( entry.second.id, dataOtypeKey );
344 if ( ! decl ) continue;
345
346 bool isCopyFunc = InitTweak::isCopyFunction( decl, decl->name );
347 if ( ! LinkageSpec::isOverridable( decl->linkage ) ) {
348 // matching user-defined function
349 if ( isCopyFunc ) {
350 // mutation already performed, return early
351 return true;
352 } else {
353 // note that non-copy deletions already performed
354 alreadyUserDefinedFunc = true;
355 }
356 } else {
357 // non-user-defined function; mark for deletion/removal as appropriate
358 if ( isCopyFunc ) {
359 removed.push_back( entry.first );
360 } else if ( ! alreadyUserDefinedFunc ) {
361 deleted.push_back( entry );
362 }
363 }
364 }
365
366 // perform removals from mangle table, and deletions if necessary
367 for ( const auto& key : removed ) {
368 ++* stats().map_mutations;
369 mangleTable = mangleTable->erase( key );
370 }
371 if ( ! alreadyUserDefinedFunc ) for ( const auto& entry : deleted ) {
372 ++* stats().map_mutations;
373 mangleTable = mangleTable->set( entry.first, IdData{ entry.second, function } );
374 }
375 } else if ( dataIsUserDefinedFunc ) {
376 // this is a user-defined non-copy function
377 // if this is the first user-defined function, delete non-user-defined overloads
378 std::vector< MangleTable::value_type > deleted;
379
380 for ( const auto& entry : * mangleTable ) {
381 // skip decls that aren't functions or are for the wrong type
382 const FunctionDecl * decl = getFunctionForOtype( entry.second.id, dataOtypeKey );
383 if ( ! decl ) continue;
384
385 // exit early if already a matching user-defined function;
386 // earlier function will have mutated table
387 if ( ! LinkageSpec::isOverridable( decl->linkage ) ) return true;
388
389 // skip mutating intrinsic functions
390 if ( decl->linkage == LinkageSpec::Intrinsic ) continue;
391
392 // user-defined non-copy functions do not override copy functions
393 if ( InitTweak::isCopyFunction( decl, decl->name ) ) continue;
394
395 // this function to be deleted after mangleTable iteration is complete
396 deleted.push_back( entry );
397 }
398
399 // mark deletions to update mangle table
400 // this needs to be a separate loop because of iterator invalidation
401 for ( const auto& entry : deleted ) {
402 ++* stats().map_mutations;
403 mangleTable = mangleTable->set( entry.first, IdData{ entry.second, function } );
404 }
405 } else if ( function->linkage != LinkageSpec::Intrinsic ) {
406 // this is an overridable generated function
407 // if there already exists a matching user-defined function, delete this appropriately
408 for ( const auto& entry : * mangleTable ) {
409 // skip decls that aren't functions or are for the wrong type
410 const FunctionDecl * decl = getFunctionForOtype( entry.second.id, dataOtypeKey );
411 if ( ! decl ) continue;
412
413 // skip non-user-defined functions
414 if ( LinkageSpec::isOverridable( decl->linkage ) ) continue;
415
416 if ( dataIsCopyFunc ) {
417 // remove current function if exists a user-defined copy function
418 // since the signatures for copy functions don't need to match exactly, using
419 // a delete statement is the wrong approach
420 if ( InitTweak::isCopyFunction( decl, decl->name ) ) return false;
421 } else {
422 // mark current function deleted by first user-defined function found
423 data.deleteStmt = decl;
424 return true;
425 }
426 }
427 }
428
429 // nothing (more) to fix, return true
430 return true;
431 }
432
433 void Indexer::addId(const DeclarationWithType * decl, OnConflict handleConflicts, const Expression * baseExpr,
434 const Declaration * deleteStmt ) {
435 ++* stats().add_calls;
436 const std::string &name = decl->name;
437 if ( name == "" ) return;
438
439 std::string mangleName;
440 if ( LinkageSpec::isOverridable( decl->linkage ) ) {
441 // mangle the name without including the appropriate suffix, so overridable routines
442 // are placed into the same "bucket" as their user defined versions.
443 mangleName = Mangler::mangle( decl, false );
444 } else {
445 mangleName = Mangler::mangle( decl );
446 } // if
447
448 // this ensures that no two declarations with the same unmangled name at the same scope
449 // both have C linkage
450 if ( LinkageSpec::isMangled( decl->linkage ) ) {
451 // Check that a Cforall declaration doesn't override any C declaration
452 if ( hasCompatibleCDecl( name, mangleName ) ) {
453 SemanticError( decl, "Cforall declaration hides C function " );
454 }
455 } else {
456 // NOTE: only correct if name mangling is completely isomorphic to C
457 // type-compatibility, which it may not be.
458 if ( hasIncompatibleCDecl( name, mangleName ) ) {
459 SemanticError( decl, "conflicting overload of C function " );
460 }
461 }
462
463 // ensure tables exist and add identifier
464 MangleTable::Ptr mangleTable;
465 if ( ! idTable ) {
466 idTable = IdTable::new_ptr();
467 mangleTable = MangleTable::new_ptr();
468 } else {
469 ++* stats().map_lookups;
470 auto decls = idTable->find( name );
471 if ( decls == idTable->end() ) {
472 mangleTable = MangleTable::new_ptr();
473 } else {
474 mangleTable = decls->second;
475 // skip in-scope repeat declarations of same identifier
476 ++* stats().map_lookups;
477 auto existing = mangleTable->find( mangleName );
478 if ( existing != mangleTable->end()
479 && existing->second.scope == scope
480 && existing->second.id ) {
481 if ( addedIdConflicts( existing->second, decl, handleConflicts, deleteStmt ) ) {
482 if ( handleConflicts.mode == OnConflict::Delete ) {
483 // set delete expression for conflicting identifier
484 lazyInitScope();
485 * stats().map_mutations += 2;
486 idTable = idTable->set(
487 name,
488 mangleTable->set(
489 mangleName,
490 IdData{ existing->second, handleConflicts.deleteStmt } ) );
491 }
492 return;
493 }
494 }
495 }
496 }
497
498 // add/overwrite with new identifier
499 lazyInitScope();
500 IdData data{ decl, baseExpr, deleteStmt, scope };
501 // Ensure that auto-generated ctor/dtor/assignment are deleted if necessary
502 if ( ! removeSpecialOverrides( data, mangleTable ) ) return;
503 * stats().map_mutations += 2;
504 idTable = idTable->set( name, mangleTable->set( mangleName, std::move(data) ) );
505 }
506
507 void Indexer::addId( const DeclarationWithType * decl, const Expression * baseExpr ) {
508 // default handling of conflicts is to raise an error
509 addId( decl, OnConflict::error(), baseExpr, decl->isDeleted ? decl : nullptr );
510 }
511
512 void Indexer::addDeletedId( const DeclarationWithType * decl, const Declaration * deleteStmt ) {
513 // default handling of conflicts is to raise an error
514 addId( decl, OnConflict::error(), nullptr, deleteStmt );
515 }
516
517 bool addedTypeConflicts( const NamedTypeDecl * existing, const NamedTypeDecl * added ) {
518 if ( existing->base == nullptr ) {
519 return false;
520 } else if ( added->base == nullptr ) {
521 return true;
522 } else {
523 assert( existing->base && added->base );
524 // typedef redeclarations are errors only if types are different
525 if ( ! ResolvExpr::typesCompatible( existing->base, added->base, Indexer() ) ) {
526 SemanticError( added->location, "redeclaration of " + added->name );
527 }
528 }
529 // does not need to be added to the table if both existing and added have a base that are
530 // the same
531 return true;
532 }
533
534 void Indexer::addType( const NamedTypeDecl * decl ) {
535 ++* stats().add_calls;
536 const std::string & id = decl->name;
537
538 if ( ! typeTable ) {
539 typeTable = TypeTable::new_ptr();
540 } else {
541 ++* stats().map_lookups;
542 auto existing = typeTable->find( id );
543 if ( existing != typeTable->end()
544 && existing->second.scope == scope
545 && addedTypeConflicts( existing->second.decl, decl ) ) return;
546 }
547
548 lazyInitScope();
549 ++* stats().map_mutations;
550 typeTable = typeTable->set( id, Scoped<NamedTypeDecl>{ decl, scope } );
551 }
552
553 bool addedDeclConflicts( const AggregateDecl * existing, const AggregateDecl * added ) {
554 if ( ! existing->body ) {
555 return false;
556 } else if ( added->body ) {
557 SemanticError( added, "redeclaration of " );
558 } // if
559 return true;
560 }
561
562 void Indexer::addStruct( const std::string & id ) {
563 addStruct( new StructDecl( id ) );
564 }
565
566 void Indexer::addStruct( const StructDecl * decl ) {
567 ++* stats().add_calls;
568 const std::string & id = decl->name;
569
570 if ( ! structTable ) {
571 structTable = StructTable::new_ptr();
572 } else {
573 ++* stats().map_lookups;
574 auto existing = structTable->find( id );
575 if ( existing != structTable->end()
576 && existing->second.scope == scope
577 && addedDeclConflicts( existing->second.decl, decl ) ) return;
578 }
579
580 lazyInitScope();
581 ++* stats().map_mutations;
582 structTable = structTable->set( id, Scoped<StructDecl>{ decl, scope } );
583 }
584
585 void Indexer::addEnum( const EnumDecl * decl ) {
586 ++* stats().add_calls;
587 const std::string & id = decl->name;
588
589 if ( ! enumTable ) {
590 enumTable = EnumTable::new_ptr();
591 } else {
592 ++* stats().map_lookups;
593 auto existing = enumTable->find( id );
594 if ( existing != enumTable->end()
595 && existing->second.scope == scope
596 && addedDeclConflicts( existing->second.decl, decl ) ) return;
597 }
598
599 lazyInitScope();
600 ++* stats().map_mutations;
601 enumTable = enumTable->set( id, Scoped<EnumDecl>{ decl, scope } );
602 }
603
604 void Indexer::addUnion( const std::string & id ) {
605 addUnion( new UnionDecl( id ) );
606 }
607
608 void Indexer::addUnion( const UnionDecl * decl ) {
609 ++* stats().add_calls;
610 const std::string & id = decl->name;
611
612 if ( ! unionTable ) {
613 unionTable = UnionTable::new_ptr();
614 } else {
615 ++* stats().map_lookups;
616 auto existing = unionTable->find( id );
617 if ( existing != unionTable->end()
618 && existing->second.scope == scope
619 && addedDeclConflicts( existing->second.decl, decl ) ) return;
620 }
621
622 lazyInitScope();
623 ++* stats().map_mutations;
624 unionTable = unionTable->set( id, Scoped<UnionDecl>{ decl, scope } );
625 }
626
627 void Indexer::addTrait( const TraitDecl * decl ) {
628 ++* stats().add_calls;
629 const std::string & id = decl->name;
630
631 if ( ! traitTable ) {
632 traitTable = TraitTable::new_ptr();
633 } else {
634 ++* stats().map_lookups;
635 auto existing = traitTable->find( id );
636 if ( existing != traitTable->end()
637 && existing->second.scope == scope
638 && addedDeclConflicts( existing->second.decl, decl ) ) return;
639 }
640
641 lazyInitScope();
642 ++* stats().map_mutations;
643 traitTable = traitTable->set( id, Scoped<TraitDecl>{ decl, scope } );
644 }
645
646 void Indexer::addMembers( const AggregateDecl * aggr, const Expression * expr, OnConflict handleConflicts ) {
647 for ( Declaration * decl : aggr->members ) {
648 if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * >( decl ) ) {
649 addId( dwt, handleConflicts, expr );
650 if ( dwt->name == "" ) {
651 const Type * t = dwt->get_type()->stripReferences();
652 if ( dynamic_cast<const StructInstType *>( t ) || dynamic_cast<const UnionInstType *>( t ) ) {
653 Expression * base = expr->clone();
654 ResolvExpr::Cost cost = ResolvExpr::Cost::zero; // xxx - carry this cost into the indexer as a base cost?
655 ResolvExpr::referenceToRvalueConversion( base, cost );
656 addMembers( t->getAggr(), new MemberExpr( dwt, base ), handleConflicts );
657 }
658 }
659 }
660 }
661 }
662
663 void Indexer::addWith( const std::list< Expression * > & withExprs, const Declaration * withStmt ) {
664 for ( const Expression * expr : withExprs ) {
665 if ( expr->result ) {
666 AggregateDecl * aggr = expr->result->stripReferences()->getAggr();
667 assertf( aggr, "WithStmt expr has non-aggregate type: %s", toString( expr->result ).c_str() );
668
669 addMembers( aggr, expr, OnConflict::deleteWith( withStmt ) );
670 }
671 }
672 }
673
674 void Indexer::addIds( const std::list< DeclarationWithType * > & decls ) {
675 for ( auto d : decls ) {
676 addId( d );
677 }
678 }
679
680 void Indexer::addTypes( const std::list< TypeDecl * > & tds ) {
681 for ( auto td : tds ) {
682 addType( td );
683 addIds( td->assertions );
684 }
685 }
686
687 void Indexer::addFunctionType( const FunctionType * ftype ) {
688 addTypes( ftype->forall );
689 addIds( ftype->returnVals );
690 addIds( ftype->parameters );
691 }
692
693 Expression * Indexer::IdData::combine( ResolvExpr::Cost & cost ) const {
694 Expression * ret = nullptr;
695 if ( baseExpr ) {
696 Expression * base = baseExpr->clone();
697 ResolvExpr::referenceToRvalueConversion( base, cost );
698 ret = new MemberExpr( const_cast<DeclarationWithType *>(id), base );
699 // xxx - this introduces hidden environments, for now remove them.
700 // std::swap( base->env, ret->env );
701 delete base->env;
702 base->env = nullptr;
703 } else {
704 ret = new VariableExpr( const_cast<DeclarationWithType *>(id) );
705 }
706 if ( deleteStmt ) ret = new DeletedExpr( ret, const_cast<Declaration *>(deleteStmt) );
707 return ret;
708 }
709} // namespace SymTab
710
711// Local Variables: //
712// tab-width: 4 //
713// mode: c++ //
714// compile-command: "make install" //
715// End: //
Note: See TracBrowser for help on using the repository browser.