Changeset d29fa5f


Ignore:
Timestamp:
Oct 2, 2017, 4:58:51 PM (4 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, new-env, no_list, persistent-indexer, resolv-new, with_gc
Children:
effdde0
Parents:
bf4b4cf
Message:

Remove has_result

Location:
src
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • src/GenPoly/Box.cc

    rbf4b4cf rd29fa5f  
    600600
    601601                        // add size/align for generic types to parameter list
    602                         if ( ! appExpr->get_function()->has_result() ) return;
     602                        if ( ! appExpr->get_function()->result ) return;
    603603                        FunctionType *funcType = getFunctionType( appExpr->get_function()->get_result() );
    604604                        assert( funcType );
     
    714714
    715715                void Pass1::boxParam( Type *param, Expression *&arg, const TyVarMap &exprTyVars ) {
    716                         assertf( arg->has_result(), "arg does not have result: %s", toString( arg ).c_str() );
     716                        assertf( arg->result, "arg does not have result: %s", toString( arg ).c_str() );
    717717                        if ( isPolyType( param, exprTyVars ) ) {
    718718                                Type * newType = arg->get_result()->clone();
     
    965965                                if ( varExpr->get_var()->get_linkage() == LinkageSpec::Intrinsic ) {
    966966                                        if ( varExpr->get_var()->get_name() == "?[?]" ) {
    967                                                 assert( appExpr->has_result() );
     967                                                assert( appExpr->result );
    968968                                                assert( appExpr->get_args().size() == 2 );
    969969                                                Type *baseType1 = isPolyPtr( appExpr->get_args().front()->get_result(), scopeTyVars, env );
     
    999999                                                } // if
    10001000                                        } else if ( varExpr->get_var()->get_name() == "*?" ) {
    1001                                                 assert( appExpr->has_result() );
     1001                                                assert( appExpr->result );
    10021002                                                assert( ! appExpr->get_args().empty() );
    10031003                                                if ( isPolyType( appExpr->get_result(), scopeTyVars, env ) ) {
     
    10161016                                                } // if
    10171017                                        } else if ( varExpr->get_var()->get_name() == "?++" || varExpr->get_var()->get_name() == "?--" ) {
    1018                                                 assert( appExpr->has_result() );
     1018                                                assert( appExpr->result );
    10191019                                                assert( appExpr->get_args().size() == 1 );
    10201020                                                if ( Type *baseType = isPolyPtr( appExpr->get_result(), scopeTyVars, env ) ) {
     
    10361036                                                } // if
    10371037                                        } else if ( varExpr->get_var()->get_name() == "++?" || varExpr->get_var()->get_name() == "--?" ) {
    1038                                                 assert( appExpr->has_result() );
     1038                                                assert( appExpr->result );
    10391039                                                assert( appExpr->get_args().size() == 1 );
    10401040                                                if ( Type *baseType = isPolyPtr( appExpr->get_result(), scopeTyVars, env ) ) {
     
    10421042                                                } // if
    10431043                                        } else if ( varExpr->get_var()->get_name() == "?+?" || varExpr->get_var()->get_name() == "?-?" ) {
    1044                                                 assert( appExpr->has_result() );
     1044                                                assert( appExpr->result );
    10451045                                                assert( appExpr->get_args().size() == 2 );
    10461046                                                Type *baseType1 = isPolyPtr( appExpr->get_args().front()->get_result(), scopeTyVars, env );
     
    10681068                                                } // if
    10691069                                        } else if ( varExpr->get_var()->get_name() == "?+=?" || varExpr->get_var()->get_name() == "?-=?" ) {
    1070                                                 assert( appExpr->has_result() );
     1070                                                assert( appExpr->result );
    10711071                                                assert( appExpr->get_args().size() == 2 );
    10721072                                                Type *baseType = isPolyPtr( appExpr->get_result(), scopeTyVars, env );
     
    11621162                void Pass1::premutate( AddressExpr * ) { visit_children = false; }
    11631163                Expression * Pass1::postmutate( AddressExpr * addrExpr ) {
    1164                         assert( addrExpr->get_arg()->has_result() && ! addrExpr->get_arg()->get_result()->isVoid() );
     1164                        assert( addrExpr->get_arg()->result && ! addrExpr->get_arg()->get_result()->isVoid() );
    11651165
    11661166                        bool needs = false;
    11671167                        if ( UntypedExpr *expr = dynamic_cast< UntypedExpr *>( addrExpr->get_arg() ) ) {
    1168                                 if ( expr->has_result() && isPolyType( expr->get_result(), scopeTyVars, env ) ) {
     1168                                if ( expr->result && isPolyType( expr->get_result(), scopeTyVars, env ) ) {
    11691169                                        if ( NameExpr *name = dynamic_cast< NameExpr *>( expr->get_function() ) ) {
    11701170                                                if ( name->get_name() == "*?" ) {
    11711171                                                        if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( expr->get_args().front() ) ) {
    1172                                                                 assert( appExpr->get_function()->has_result() );
     1172                                                                assert( appExpr->get_function()->result );
    11731173                                                                FunctionType *function = getFunctionType( appExpr->get_function()->get_result() );
    11741174                                                                assert( function );
  • src/GenPoly/Specialize.cc

    rbf4b4cf rd29fa5f  
    147147
    148148        Expression * Specialize::doSpecialization( Type *formalType, Expression *actual, InferredParams *inferParams ) {
    149                 assertf( actual->has_result(), "attempting to specialize an untyped expression" );
     149                assertf( actual->result, "attempting to specialize an untyped expression" );
    150150                if ( needsSpecialization( formalType, actual->get_result(), env ) ) {
    151151                        if ( FunctionType *funType = getFunctionType( formalType ) ) {
  • src/InitTweak/FixInit.cc

    rbf4b4cf rd29fa5f  
    390390                        assert( env );
    391391                        CP_CTOR_PRINT( std::cerr << "Type Substitution: " << *env << std::endl; )
    392                         assert( arg->has_result() );
     392                        assert( arg->result );
    393393                        Type * result = arg->get_result();
    394394                        if ( skipCopyConstruct( result ) ) return; // skip certain non-copyable types
     
    11251125                        static UniqueName tempNamer( "_tmp_ctor_expr" );
    11261126                        // xxx - is the size check necessary?
    1127                         assert( ctorExpr->has_result() && ctorExpr->get_result()->size() == 1 );
     1127                        assert( ctorExpr->result && ctorExpr->get_result()->size() == 1 );
    11281128
    11291129                        // xxx - ideally we would reuse the temporary generated from the copy constructor passes from within firstArg if it exists and not generate a temporary if it's unnecessary.
  • src/ResolvExpr/AlternativeFinder.cc

    rbf4b4cf rd29fa5f  
    839839        bool isLvalue( Expression *expr ) {
    840840                // xxx - recurse into tuples?
    841                 return expr->has_result() && ( expr->get_result()->get_lvalue() || dynamic_cast< ReferenceType * >( expr->get_result() ) );
     841                return expr->result && ( expr->get_result()->get_lvalue() || dynamic_cast< ReferenceType * >( expr->get_result() ) );
    842842        }
    843843
  • src/ResolvExpr/ResolveTypeof.cc

    rbf4b4cf rd29fa5f  
    6363                if ( typeofType->get_expr() ) {
    6464                        Expression *newExpr = resolveInVoidContext( typeofType->get_expr(), indexer );
    65                         assert( newExpr->has_result() && ! newExpr->get_result()->isVoid() );
     65                        assert( newExpr->result && ! newExpr->get_result()->isVoid() );
    6666                        Type *newType = newExpr->get_result();
    6767                        newExpr->set_result( nullptr );
  • src/SynTree/AddressExpr.cc

    rbf4b4cf rd29fa5f  
    3333        Type * addrType( Type * type ) {
    3434                if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( type ) ) {
    35                         return new ReferenceType( refType->get_qualifiers(), addrType( refType->get_base() ) );
     35                        return new ReferenceType( refType->get_qualifiers(), addrType( refType->base ) );
    3636                } else {
    3737                        return new PointerType( Type::Qualifiers(), type->clone() );
     
    4141
    4242AddressExpr::AddressExpr( Expression *arg ) : Expression(), arg( arg ) {
    43         if ( arg->has_result() ) {
    44                 if ( arg->get_result()->get_lvalue() ) {
     43        if ( arg->result ) {
     44                if ( arg->result->get_lvalue() ) {
    4545                        // lvalue, retains all layers of reference and gains a pointer inside the references
    46                         set_result( addrType( arg->get_result() ) );
     46                        set_result( addrType( arg->result ) );
    4747                } else {
    4848                        // taking address of non-lvalue -- must be a reference, loses one layer of reference
    49                         ReferenceType * refType = strict_dynamic_cast< ReferenceType * >( arg->get_result() );
    50                         set_result( addrType( refType->get_base() ) );
     49                        ReferenceType * refType = strict_dynamic_cast< ReferenceType * >( arg->result );
     50                        set_result( addrType( refType->base ) );
    5151                }
    5252                // result of & is never an lvalue
  • src/SynTree/ApplicationExpr.cc

    rbf4b4cf rd29fa5f  
    5555        set_result( ResolvExpr::extractResultType( function ) );
    5656
    57         assert( has_result() );
     57        assert( result );
    5858}
    5959
  • src/SynTree/Expression.h

    rbf4b4cf rd29fa5f  
    4545        const Type * get_result() const { return result; }
    4646        void set_result( Type * newValue ) { result = newValue; }
    47         bool has_result() const { return result != nullptr; }
    4847
    4948        TypeSubstitution * get_env() const { return env; }
  • src/Tuples/TupleAssignment.cc

    rbf4b4cf rd29fa5f  
    8484        bool isTuple( Expression *expr ) {
    8585                if ( ! expr ) return false;
    86                 assert( expr->has_result() );
     86                assert( expr->result );
    8787                return dynamic_cast< TupleType * >( expr->get_result()->stripReferences() );
    8888        }
     
    238238
    239239        ObjectDecl * TupleAssignSpotter::Matcher::newObject( UniqueName & namer, Expression * expr ) {
    240                 assert( expr->has_result() && ! expr->get_result()->isVoid() );
     240                assert( expr->result && ! expr->get_result()->isVoid() );
    241241                ObjectDecl * ret = new ObjectDecl( namer.newName(), Type::StorageClasses(), LinkageSpec::Cforall, nullptr, expr->get_result()->clone(), new SingleInit( expr->clone() ) );
    242242                // if expression type is a reference, don't need to construct anything, a simple initializer is sufficient.
Note: See TracChangeset for help on using the changeset viewer.