Changeset 062e8df


Ignore:
Timestamp:
Jul 9, 2018, 10:31:04 AM (3 years ago)
Author:
Rob Schluntz <rschlunt@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, deferred_resn, demangler, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, no_list, persistent-indexer
Children:
0bcc2b7
Parents:
49e1275
Message:

Add error checks for nested types

File:
1 edited

Legend:

Unmodified
Added
Removed
  • src/SymTab/Validate.cc

    r49e1275 r062e8df  
    351351
    352352        Type * FixQualifiedTypes::postmutate( QualifiedType * qualType ) {
    353                 // TODO: change asserts to SemanticErrors as necessary
    354353                Type * parent = qualType->parent;
    355354                Type * child = qualType->child;
    356355                if ( dynamic_cast< GlobalScopeType * >( qualType->parent ) ) {
    357356                        // .T => lookup T at global scope
    358                         if ( StructInstType * inst = dynamic_cast< StructInstType * >( child ) ) {
    359                                 auto aggr = indexer.globalLookupStruct( inst->name );
    360                                 return new StructInstType( qualType->get_qualifiers(), aggr );
    361                         } else if ( UnionInstType * inst = dynamic_cast< UnionInstType * >( child ) ) {
    362                                 auto aggr =  indexer.globalLookupUnion( inst->name );
    363                                 return new UnionInstType( qualType->get_qualifiers(), aggr );
    364                         } else if ( EnumInstType * inst = dynamic_cast< EnumInstType * >( child ) ) {
    365                                 auto aggr = indexer.globalLookupEnum( inst->name );
    366                                 return new EnumInstType( qualType->get_qualifiers(), aggr );
    367                         } else if ( TypeInstType * inst = dynamic_cast< TypeInstType * >( child ) ) {
     357                        if ( TypeInstType * inst = dynamic_cast< TypeInstType * >( child ) ) {
    368358                                auto td = indexer.globalLookupType( inst->name );
    369                                 assertf( td, "did not find type at global scope with name: %s", inst->name.c_str() );
     359                                if ( ! td ) {
     360                                        SemanticError( qualType->location, toString("Use of undefined global type ", inst->name) );
     361                                }
    370362                                auto base = td->base;
    371                                 if ( base ) return td->base->clone();
    372                                 assert( false );
     363                                assert( base );
     364                                return base->clone();
    373365                        } else {
    374                                 // .T => T is not a SUE type name
    375                                 assert( false );
     366                                // .T => T is not a type name
     367                                assertf( false, "unhandled global qualified child type: %s", toCString(child) );
    376368                        }
    377369                } else {
     
    383375                                aggr = inst->baseUnion;
    384376                        } else {
    385                                 assert( false );
     377                                SemanticError( qualType->location, toString("Qualified type requires an aggregate on the left, but has: ", parent) );
    386378                        }
    387379                        assert( aggr ); // TODO: need to handle forward declarations
     
    409401                                        if ( NamedTypeDecl * aggr = dynamic_cast< NamedTypeDecl * > ( member ) ) {
    410402                                                if ( aggr->name == inst->name ) {
    411                                                         if ( aggr->base ) return aggr->base->clone();
    412                                                         assert( false );
     403                                                        assert( aggr->base );
     404                                                        return aggr->base->clone();
    413405                                                }
    414406                                        }
     
    419411                        }
    420412                        // failed to find a satisfying definition of type
    421                         assertf( false, "failed to find a satisfying definition of %s in %s", toCString(child), toCString(parent) );
     413                        SemanticError( qualType->location, toString("Undefined type in qualified type: ", qualType) );
    422414                }
    423415
     
    919911                } else {
    920912                        TypeDeclMap::const_iterator base = typedeclNames.find( typeInst->name );
    921                         assertf( base != typedeclNames.end(), "Cannot find typedecl name %s", typeInst->name.c_str() );
     913                        if ( base == typedeclNames.end() ) {
     914                                SemanticError( typeInst->location, toString("Use of undefined type ", typeInst->name) );
     915                        }
    922916                        typeInst->set_baseType( base->second );
    923                 } // if
    924                 return typeInst;
     917                        return typeInst;
     918                } // if
     919                assert( false );
    925920        }
    926921
Note: See TracChangeset for help on using the changeset viewer.