Changeset a4a000d


Ignore:
Timestamp:
Sep 13, 2018, 4:37:26 PM (3 years ago)
Author:
Aaron Moss <a3moss@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, deferred_resn, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, no_list, persistent-indexer
Children:
6e9ffd1
Parents:
4d59ff9
Message:

support assertions in RPDump

File:
1 edited

Legend:

Unmodified
Added
Removed
  • src/CodeTools/ResolvProtoDump.cc

    r4d59ff9 ra4a000d  
    3939        /// Visitor for dumping resolver prototype output
    4040        class ProtoDump : public WithShortCircuiting, public WithVisitorRef<ProtoDump> {
    41                 std::set<std::string> decls;     ///< Declarations in this scope
    42                 std::vector<std::string> exprs;  ///< Expressions in this scope
    43                 std::vector<ProtoDump> subs;     ///< Sub-scopes
    44                 const ProtoDump* parent;         ///< Outer lexical scope
    45                 std::unique_ptr<Type> rtnType;   ///< Return type for this scope
     41                std::set<std::string> decls;             ///< Declarations in this scope
     42                std::vector<std::string> exprs;          ///< Expressions in this scope
     43                std::vector<ProtoDump> subs;             ///< Sub-scopes
     44                std::unordered_set<std::string> closed;  ///< Closed type variables
     45                const ProtoDump* parent;                 ///< Outer lexical scope
     46                std::unique_ptr<Type> rtnType;           ///< Return type for this scope
    4647
    4748        public:
    4849                /// Default constructor for root ProtoDump
    49                 ProtoDump() : decls(), exprs(), subs(), parent(nullptr), rtnType(nullptr) {}
     50                ProtoDump() : decls(), exprs(), subs(), closed(), parent(nullptr), rtnType(nullptr) {}
    5051
    5152                /// Child constructor
    52                 ProtoDump(const ProtoDump* p, Type* r) : decls(), exprs(), subs(), parent(p), rtnType(r) {}
     53                ProtoDump(const ProtoDump* p, Type* r)
     54                        : decls(), exprs(), subs(), closed(p->closed), parent(p), rtnType(r) {}
    5355
    5456                // Fix copy issues
    55                 ProtoDump( const ProtoDump& o )
    56                         : decls(o.decls), exprs(o.exprs), subs(o.subs), parent(o.parent),
     57                ProtoDump(const ProtoDump& o)
     58                        : decls(o.decls), exprs(o.exprs), subs(o.subs), closed(o.closed), parent(o.parent),
    5759                          rtnType(maybeClone(o.rtnType.get())) {}
    5860                ProtoDump( ProtoDump&& ) = default;
    5961
    60                 ProtoDump& operator= ( const ProtoDump& o ) {
     62                ProtoDump& operator= (const ProtoDump& o) {
    6163                        if ( this == &o ) return *this;
    6264
     
    6466                        exprs = o.exprs;
    6567                        subs = o.subs;
     68                        closed = o.closed;
    6669                        parent = o.parent;
    6770                        rtnType.reset( maybeClone(o.rtnType.get()) );
     
    6972                        return *this;
    7073                }
    71                 ProtoDump& operator= ( ProtoDump&& ) = default;
     74                ProtoDump& operator= (ProtoDump&&) = default;
    7275
    7376        private:
     
    205208                /// Visitor for printing types
    206209                struct TypePrinter : public WithShortCircuiting, WithVisitorRef<TypePrinter>, WithGuards {
    207                         std::stringstream& ss;  ///< Output to print to
    208                         unsigned depth;         ///< Depth of nesting from root type
    209 
    210                         TypePrinter( std::stringstream& ss ) : ss(ss), depth(0) {}
     210                        std::stringstream& ss;                          ///< Output to print to
     211                        const std::unordered_set<std::string>& closed;  ///< Closed type variables
     212                        unsigned depth;                                 ///< Depth of nesting from root type
     213
     214                        TypePrinter( const std::unordered_set<std::string>& closed, std::stringstream& ss )
     215                                : ss(ss), closed(closed), depth(0) {}
    211216
    212217                        // basic type represented as integer type
     
    274279                        void previsit( EnumInstType* ) { ss << (int)BasicType::SignedInt; }
    275280
    276                         // make sure first letter of TypeInstType is capitalized
    277281                        void previsit( TypeInstType* vt ) {
    278                                 ti_name( vt->name, ss );
     282                                // print closed variables as named types
     283                                if ( closed.count( vt->name ) ) { ss << '#' << vt->name; }
     284                                // otherwise make sure first letter is capitalized
     285                                else { ti_name( vt->name, ss ); }
    279286                        }
    280287
     
    302309                /// builds description of function
    303310                void build( const std::string& name, FunctionType* fnTy, std::stringstream& ss ) {
    304                         PassVisitor<TypePrinter> printTy{ ss };
     311                        PassVisitor<TypePrinter> printTy{ closed, ss };
     312                        // print return values
    305313                        build( printTy, from_decls( fnTy->returnVals ), ss, terminated );
     314                        // print name
    306315                        rp_name( name, ss );
     316                        // print parameters
    307317                        build( printTy, from_decls( fnTy->parameters ), ss, preceded );
    308                         // TODO handle assertions
     318                        // print assertions
     319                        for ( TypeDecl* tyvar : fnTy->forall ) {
     320                                for ( DeclarationWithType* assn : tyvar->assertions ) {
     321                                        ss << " | ";
     322                                        build( assn->name, assn->get_type(), ss );
     323                                }
     324                        }
    309325                }
    310326
     
    326342
    327343                        // print variable declaration as zero-arg function
    328                         PassVisitor<TypePrinter> printTy{ ss };
     344                        PassVisitor<TypePrinter> printTy{ closed, ss };
    329345                        norefs->accept( printTy );
    330346                        ss << ' ';
     
    338354
    339355                        // print access as new field name
    340                         PassVisitor<TypePrinter> printTy{ ss };
     356                        PassVisitor<TypePrinter> printTy{ closed, ss };
    341357                        norefs->accept( printTy );
    342358                        ss << ' ';
     
    359375                struct ExprPrinter : WithShortCircuiting, WithVisitorRef<ExprPrinter> {
    360376                        // TODO change interface to generate multiple expression candidates
    361 
    362                         std::stringstream& ss;  ///< Output to print to
    363 
    364                         ExprPrinter( std::stringstream& ss ) : ss(ss) {}
     377                        const std::unordered_set<std::string>& closed;  ///< set of closed type vars
     378                        std::stringstream& ss;                          ///< Output to print to
     379
     380                        ExprPrinter( const std::unordered_set<std::string>& closed, std::stringstream& ss )
     381                                : closed(closed), ss(ss) {}
    365382
    366383                        /// Names handled as nullary function calls
     
    401418                        /// Address-of handled as operator
    402419                        void previsit( AddressExpr* expr ) {
    403                                 // TODO global function to implement this
    404420                                ss << "$addr( ";
    405421                                expr->arg->accept( *visitor );
     
    411427                        /// TODO put cast target functions in, and add second expression for target
    412428                        void previsit( CastExpr* cast ) {
    413                                 PassVisitor<TypePrinter> tyPrinter{ ss };
     429                                PassVisitor<TypePrinter> tyPrinter{ closed, ss };
    414430                                cast->result->accept( tyPrinter );
    415431                                visit_children = false;
     
    438454                        /// Constant expression replaced by its type
    439455                        void previsit( ConstantExpr* expr ) {
    440                                 PassVisitor<TypePrinter> tyPrinter{ ss };
     456                                PassVisitor<TypePrinter> tyPrinter{ closed, ss };
    441457                                expr->constant.get_type()->accept( tyPrinter );
    442458                                visit_children = false;
     
    460476                        /// Logical expressions represented as operators
    461477                        void previsit( LogicalExpr* expr ) {
    462                                 // TODO global functions for these
    463478                                ss << '$' << ( expr->get_isAnd() ? "and" : "or" ) << "( ";
    464479                                expr->arg1->accept( *visitor );
     
    471486                        /// Conditional expression represented as operator
    472487                        void previsit( ConditionalExpr* expr ) {
    473                                 // TODO global function for this
    474488                                ss << "$if( ";
    475489                                expr->arg1->accept( *visitor );
     
    484498                        /// Comma expression represented as operator
    485499                        void previsit( CommaExpr* expr ) {
    486                                 // TODO global function for this
    487500                                ss << "$seq( ";
    488501                                expr->arg1->accept( *visitor );
     
    498511                void build( Initializer* init, std::stringstream& ss ) {
    499512                        if ( SingleInit* si = dynamic_cast<SingleInit*>(init) ) {
    500                                 PassVisitor<ExprPrinter> exprPrinter{ ss };
     513                                PassVisitor<ExprPrinter> exprPrinter{ closed, ss };
    501514                                si->value->accept( exprPrinter );
    502515                                ss << ' ';
     
    521534                void build( Type* rtnType, Expression* expr, std::stringstream& ss ) {
    522535                        ss << "$constructor( ";
    523                         PassVisitor<TypePrinter> tyPrinter{ ss };
     536                        PassVisitor<TypePrinter> tyPrinter{ closed, ss };
    524537                        rtnType->accept( tyPrinter );
    525538                        ss << ' ';
    526                         PassVisitor<ExprPrinter> exprPrinter{ ss };
     539                        PassVisitor<ExprPrinter> exprPrinter{ closed, ss };
    527540                        expr->accept( exprPrinter );
    528541                        ss << " )";
     
    587600                                }
    588601                                PassVisitor<ProtoDump> body{ this, rtn };
     602
     603                                for ( TypeDecl* tyvar : decl->type->forall ) {
     604                                        // add set of "closed" types to body so that it can print them as NamedType
     605                                        body.pass.closed.insert( tyvar->name );
     606
     607                                        // add assertions to local scope as declarations as well
     608                                        for ( DeclarationWithType* assn : tyvar->assertions ) {
     609                                                assn->accept( body );
     610                                        }
     611                                }
    589612                               
    590613                                // add named parameters and returns to local scope
    591614                                body.pass.addAll( decl->type->returnVals );
    592615                                body.pass.addAll( decl->type->parameters );
    593                                
    594                                 // TODO add assertions to local scope
    595 
    596                                 // TODO add set of "closed" types to body so that it can print them as NamedType
    597616
    598617                                // add contents of function to new scope
     
    636655                void previsit( Expression* expr ) {
    637656                        std::stringstream ss;
    638                         PassVisitor<ExprPrinter> exPrinter{ss};
     657                        PassVisitor<ExprPrinter> exPrinter{ closed, ss };
    639658                        expr->accept( exPrinter );
    640659                        addExpr( ss.str() );
     
    642661                }
    643662
     663                /// Print non-prelude global declarations for resolv proto
     664                void printGlobals() const {
     665                        std::cout << "#ptr<T> $addr T" << std::endl;  // &?
     666                        int i = (int)BasicType::SignedInt;
     667                        std::cout << i << " $and " << i << ' ' << i << std::endl;  // ?&&?
     668                        std::cout << i << " $or " << i << ' ' << i << std::endl;  // ?||?
     669                        std::cout << "T $if " << i << " T T" << std::endl; // ternary operator
     670                        std::cout << "T $seq X T" << std::endl;  // ?,?
     671                }
     672
    644673        public:
    645674                /// Prints this ProtoDump instance
    646675                void print(unsigned indent = 0) const {
     676                        // print globals at root level
     677                        if ( ! parent ) printGlobals();
     678                        // print decls
    647679                        std::string tab( indent, '\t' );
    648                         // print decls
    649680                        for ( const std::string& d : decls ) {
    650681                                std::cout << tab << d << std::endl;
Note: See TracChangeset for help on using the changeset viewer.