Changeset d9fa60a

Timestamp:

Nov 16, 2016, 4:37:50 PM (7 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

186fd86

Parents:

33a7b6d

Message:

moved substituion into MemberExpr? constructor, change generated tuple structs to generic structs, tuples containing type variables almost works

Location:

src

Files:

• GenPoly/Box.cc (modified) (8 diffs)
• GenPoly/PolyMutator.cc (modified) (2 diffs)
• GenPoly/PolyMutator.h (modified) (1 diff)
• InitTweak/FixInit.cc (modified) (1 diff)
• ResolvExpr/AlternativeFinder.cc (modified) (1 diff)
• SymTab/Autogen.cc (modified) (2 diffs)
• SynTree/Expression.cc (modified) (1 diff)
• Tuples/TupleExpansion.cc (modified) (2 diffs)
• main.cc (modified) (2 diffs)
• tests/tupleFunction.c (modified) (2 diffs)

src/GenPoly/Box.cc

@@ -98 +98 @@
                         void passArgTypeVars( ApplicationExpr *appExpr, Type *parmType, Type *argBaseType, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars, std::set< std::string > &seenTypes );
                         /// passes extra type parameters into a polymorphic function application
-                        void passTypeVars( ApplicationExpr *appExpr, ReferenceToType *polyRetType, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars );
+                        void passTypeVars( ApplicationExpr *appExpr, Type *polyRetType, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars );
                         /// wraps a function application with a new temporary for the out-parameter return value
                         Expression *addRetParam( ApplicationExpr *appExpr, FunctionType *function, Type *retType, std::list< Expression *>::iterator &arg );
@@ -107 +107 @@
                         Type *replaceWithConcrete( ApplicationExpr *appExpr, Type *type, bool doClone = true );
                         /// wraps a function application returning a polymorphic type with a new temporary for the out-parameter return value
-                        Expression *addDynRetParam( ApplicationExpr *appExpr, FunctionType *function, ReferenceToType *polyType, std::list< Expression *>::iterator &arg );
+                        Expression *addDynRetParam( ApplicationExpr *appExpr, FunctionType *function, Type *polyType, std::list< Expression *>::iterator &arg );
                         Expression *applyAdapter( ApplicationExpr *appExpr, FunctionType *function, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars );
                         void boxParam( Type *formal, Expression *&arg, const TyVarMap &exprTyVars );
@@ -769 +769 @@
                 }
 
-                void Pass1::passTypeVars( ApplicationExpr *appExpr, ReferenceToType *polyRetType, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars ) {
+                void Pass1::passTypeVars( ApplicationExpr *appExpr, Type *polyRetType, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars ) {
                         // pass size/align for type variables
                         for ( TyVarMap::const_iterator tyParm = exprTyVars.begin(); tyParm != exprTyVars.end(); ++tyParm ) {
@@ -818 +818 @@
 
                 Expression *Pass1::addRetParam( ApplicationExpr *appExpr, FunctionType *function, Type *retType, std::list< Expression *>::iterator &arg ) {
-                        // ***** Code Removal ***** After introducing a temporary variable for all return expressions, the following code appears superfluous.
-                        // if ( useRetval ) {
-                        //      assert( retval );
-                        //      arg = appExpr->get_args().insert( arg, new VariableExpr( retval ) );
-                        //      arg++;
-                        // } else {
-
                         // Create temporary to hold return value of polymorphic function and produce that temporary as a result
                         // using a comma expression.  Possibly change comma expression into statement expression "{}" for multiple
                         // return values.
+                        assert( retType );
                         ObjectDecl *newObj = makeTemporary( retType->clone() );
                         Expression *paramExpr = new VariableExpr( newObj );
@@ -843 +837 @@
                         appExpr->set_env( 0 );
                         return commaExpr;
-                        // } // if
-                        // return appExpr;
                 }
 
@@ -878 +870 @@
                 }
 
-                Expression *Pass1::addDynRetParam( ApplicationExpr *appExpr, FunctionType *function, ReferenceToType *dynType, std::list< Expression *>::iterator &arg ) {
+                Expression *Pass1::addDynRetParam( ApplicationExpr *appExpr, FunctionType *function, Type *dynType, std::list< Expression *>::iterator &arg ) {
                         assert( env );
                         Type *concrete = replaceWithConcrete( appExpr, dynType );
@@ -1288 +1280 @@
                         TyVarMap exprTyVars( (TypeDecl::Kind)-1 );
                         makeTyVarMap( function, exprTyVars );
-                        ReferenceToType *concRetType = dynamic_cast< ReferenceToType* >( appExpr->get_result() ); // xxx - is concRetType a good name?
                         ReferenceToType *dynRetType = isDynRet( function, exprTyVars );
+                        Type *concRetType = appExpr->get_result();// ?: dynRetType; // xxx - is concRetType a good name?
 
                         if ( dynRetType ) {
@@ -1589 +1581 @@
                         // move polymorphic return type to parameter list
                         if ( isDynRet( funcType ) ) {
-                                DeclarationWithType *ret = funcType->get_returnVals().front();
+                                ObjectDecl *ret = safe_dynamic_cast< ObjectDecl* >( funcType->get_returnVals().front() );
                                 ret->set_type( new PointerType( Type::Qualifiers(), ret->get_type() ) );
                                 funcType->get_parameters().push_front( ret );
                                 funcType->get_returnVals().pop_front();
+                                ret->set_init( nullptr ); // xxx - memory leak?
                         }
 

src/GenPoly/PolyMutator.cc

@@ -149 +149 @@
         }
 
+        Expression *PolyMutator::mutate( StmtExpr * stmtExpr ) {
+                // don't want statements from outer CompoundStmts to be added to this StmtExpr
+                ValueGuard< std::list< Statement* > > oldStmtsToAdd( stmtsToAdd );
+                ValueGuard< std::list< Statement* > > oldStmtsToAddAfter( stmtsToAddAfter );
+
+                // xxx - not sure if these are needed, along with appropriate assignments, but I don't think so...
+                // ValueGuard< TyVarMap > oldScopeTyVars;
+                // ValueGuard< TypeSubstitution * > oldEnv;
+
+                stmtsToAdd.clear();
+                stmtsToAddAfter.clear();
+
+                stmtExpr->set_result( maybeMutate( stmtExpr->get_result(), *this ) );
+                stmtExpr->set_statements( maybeMutate( stmtExpr->get_statements(), *this ) );
+                return stmtExpr;
+        }
 
         Initializer *PolyMutator::mutate( SingleInit *singleInit ) {
@@ -154 +170 @@
                 return singleInit;
         }
-
 } // namespace GenPoly
 

src/GenPoly/PolyMutator.h

@@ -47 +47 @@
 
                 virtual Expression* mutate(UntypedExpr *untypedExpr);
+                virtual Expression* mutate( StmtExpr *stmtExpr );
 
                 virtual Initializer* mutate(SingleInit *SingleInit);

src/InitTweak/FixInit.cc

@@ -904 +904 @@
                                         // insert and resolve default/copy constructor call for each field that's unhandled
                                         std::list< Statement * > stmt;
-                                        UntypedExpr * deref = new UntypedExpr( new NameExpr( "*?" ) );
-                                        deref->get_args().push_back( new VariableExpr( thisParam ) );
+                                        UntypedExpr * deref = UntypedExpr::createDeref( new VariableExpr( thisParam ) );
 
                                         Expression * arg2 = 0;

src/ResolvExpr/AlternativeFinder.cc

@@ -218 +218 @@
                 std::list< Declaration* > members;
                 aggInst->lookup( name, members );
-                TypeSubstitution sub = TypeSubstitution( aggInst->get_baseParameters()->begin(), aggInst->get_baseParameters()->end(), aggInst->get_parameters().begin() );
                 for ( std::list< Declaration* >::const_iterator i = members.begin(); i != members.end(); ++i ) {
                         if ( DeclarationWithType *dwt = dynamic_cast< DeclarationWithType* >( *i ) ) {
-                                MemberExpr * memExpr = new MemberExpr( dwt, expr->clone() );
-                                sub.apply( memExpr );
-                                alternatives.push_back( Alternative( memExpr, env, newCost ) );
+                                alternatives.push_back( Alternative( new MemberExpr( dwt, expr->clone() ), env, newCost ) );
                                 renameTypes( alternatives.back().expr );
                         } else {

src/SymTab/Autogen.cc

@@ -175 +175 @@
 
         void makeStructMemberOp( ObjectDecl * dstParam, Expression * src, DeclarationWithType * field, FunctionDecl * func, TypeSubstitution & genericSubs, bool isDynamicLayout, bool forward = true ) {
-//              if ( isDynamicLayout && src ) {
-//                      genericSubs.apply( src );
-//              }
-
                 ObjectDecl * returnVal = NULL;
                 if ( ! func->get_functionType()->get_returnVals().empty() ) {
@@ -187 +183 @@
 
                 // assign to destination (and return value if generic)
-                UntypedExpr *derefExpr = new UntypedExpr( new NameExpr( "*?" ) );
-                derefExpr->get_args().push_back( new VariableExpr( dstParam ) );
+                UntypedExpr *derefExpr = UntypedExpr::createDeref( new VariableExpr( dstParam ) );
                 Expression *dstselect = new MemberExpr( field, derefExpr );
                 genImplicitCall( srcParam, dstselect, func->get_name(), back_inserter( func->get_statements()->get_kids() ), field, forward );
 
                 if ( isDynamicLayout && returnVal ) {
-                        UntypedExpr *derefRet = new UntypedExpr( new NameExpr( "*?" ) );
-                        derefRet->get_args().push_back( new VariableExpr( returnVal ) );
-                        Expression *retselect = new MemberExpr( field, derefRet );
+                        // xxx - there used to be a dereference on returnVal, but this seems to have been wrong?
+                        Expression *retselect = new MemberExpr( field, new VariableExpr( returnVal ) );
                         genImplicitCall( srcParam, retselect, func->get_name(), back_inserter( func->get_statements()->get_kids() ), field, forward );
                 } // if

src/SynTree/Expression.cc

@@ -332 +332 @@
 }
 
+namespace {
+        TypeSubstitution makeSub( Type * t ) {
+                if ( StructInstType * aggInst = dynamic_cast< StructInstType * >( t ) ) {
+                        return TypeSubstitution( aggInst->get_baseParameters()->begin(), aggInst->get_baseParameters()->end(), aggInst->get_parameters().begin() );
+                } else if ( UnionInstType * aggInst = dynamic_cast< UnionInstType * >( t ) ) {
+                        return TypeSubstitution( aggInst->get_baseParameters()->begin(), aggInst->get_baseParameters()->end(), aggInst->get_parameters().begin() );
+                } else {
+                        assertf( false, "makeSub expects struct or union type for aggregate" );
+                }
+        }
+}
+
 
 MemberExpr::MemberExpr( DeclarationWithType *_member, Expression *_aggregate, Expression *_aname ) :
                 Expression( _aname ), member(_member), aggregate(_aggregate) {
-        set_result( member->get_type()->clone() );
+
+        TypeSubstitution sub( makeSub( aggregate->get_result() ) );
+        Type * res = member->get_type()->clone();
+        sub.apply( res );
+        set_result( res );
         get_result()->set_isLvalue( true );
 }

src/Tuples/TupleExpansion.cc

@@ -93 +93 @@
                         typedef Mutator Parent;
                         using Parent::mutate;
-                        
+
                         virtual Expression * mutate( TupleExpr * tupleExpr ) override;
                 };
@@ -218 +218 @@
         Type * TupleTypeReplacer::mutate( TupleType * tupleType ) {
                 std::string mangleName = SymTab::Mangler::mangleType( tupleType );
-                TupleType * newType = safe_dynamic_cast< TupleType * > ( Parent::mutate( tupleType ) );
+                tupleType = safe_dynamic_cast< TupleType * > ( Parent::mutate( tupleType ) );
                 if ( ! typeMap.count( mangleName ) ) {
                         // generate struct type to replace tuple type
                         StructDecl * decl = new StructDecl( "_tuple_type_" + mangleName );
                         decl->set_body( true );
-                        int cnt = 0;
-                        for ( Type * t : *newType ) {
-                                decl->get_members().push_back( new ObjectDecl( toString("field_", cnt++), DeclarationNode::NoStorageClass, LinkageSpec::C, nullptr, t->clone(), nullptr ) );
+                        for ( size_t i = 0; i < tupleType->size(); ++i ) {
+                                TypeDecl * tyParam = new TypeDecl( toString("tuple_param_", i), DeclarationNode::NoStorageClass, nullptr, TypeDecl::Any );
+                                decl->get_members().push_back( new ObjectDecl( toString("field_", i), DeclarationNode::NoStorageClass, LinkageSpec::C, nullptr, new TypeInstType( Type::Qualifiers(), tyParam->get_name(), tyParam ), nullptr ) );
+                                decl->get_parameters().push_back( tyParam );
                         }
                         typeMap[mangleName] = decl;
                         addDeclaration( decl );
                 }
-                Type::Qualifiers qualifiers = newType->get_qualifiers();
-                delete newType;
-                return new StructInstType( qualifiers, typeMap[mangleName] );
+                Type::Qualifiers qualifiers = tupleType->get_qualifiers();
+
+                StructDecl * decl = typeMap[mangleName];
+                StructInstType * newType = new StructInstType( qualifiers, decl );
+                for ( Type * t : *tupleType ) {
+                        newType->get_parameters().push_back( new TypeExpr( t->clone() ) );
+                }
+                delete tupleType;
+                return newType;
         }
 

src/main.cc

@@ -266 +266 @@
                 OPTPRINT( "expandUniqueExpr" ); // xxx - is this the right place for this? want to expand ASAP so that subsequent passes don't need to worry about double-visiting a unique expr - needs to go after InitTweak::fix so that copy constructed return declarations are reused
                 Tuples::expandUniqueExpr( translationUnit );
+                OPTPRINT( "expandTuples" ); // xxx - is this the right place for this?
+                Tuples::expandTuples( translationUnit );
 
                 OPTPRINT("instantiateGenerics")
@@ -282 +284 @@
                 OPTPRINT( "box" )
                 GenPoly::box( translationUnit );
-                OPTPRINT( "expandTuples" ); // xxx - is this the right place for this?
-                Tuples::expandTuples( translationUnit );
 
                 // print tree right before code generation

src/tests/tupleFunction.c

@@ -51 +51 @@
 }
 
-// forall(otype T | { T ?+?(T, T); })
-// [T, T, T] ?+?([T, T, T] x, [T, T, T] y) {
-//      T x1, x2, x3, y1, y2, y3;
-//      [x1, x2, x3] = x;
-//      [y1, y2, y3] = y;
-//      return [x1+y1, x2+y2, x3+y3];
-// }
+int main() {
+        [int, double, int] x = [777, 2.76, 8675];
+        int x1 = 123, x3 = 456;
+        double x2 = 999.123;
 
-int main() {
-  [int, double, int] x = [777, 2.76, 8675];
-  int x1 = 123, x3 = 456;
-  double x2 = 999.123;
-
-  printf("foo(...)=%d\n", foo(x1, x3, x2, (S){ 321, 654, 'Q', 3.14 }));
+        printf("foo(...)=%d\n", foo(x1, x3, x2, (S){ 321, 654, 'Q', 3.14 }));
 
         // call function with tuple parameter using tuple variable arg
@@ -91 +83 @@
         [x1, x2, x3] = quux();
         printf("x1=%d x2=%lg x3=%d\n", x1, x2, x3);
+
+        // xxx - tuples of type parameters should come out as generic types?
+        // [x1, x2, x3] = ([(int)x1, (int)x2, (int)x3]) + ([(int)1, (int)2, (int)3]);
+        // ([(int)x1, (int)x2, (int)x3]) + ([(int)1, (int)2, (int)3]);
+        // printf("%d %g %d\n", x1, x2, x3);
+
+        // xxx - comes out the back as a cast, but should come out as a tuple expression of the first n fields cast to each of the result types
+        // ([int, double])x;
 }