Changes in src/GenPoly/Box.cc [aa19ccf:c2ad3c9]

File:

• src/GenPoly/Box.cc (modified) (46 diffs)

src/GenPoly/Box.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Feb  5 16:45:07 2016
-// Update Count     : 286
+// Last Modified By : Rob Schluntz
+// Last Modified On : Fri May 13 14:51:21 2016
+// Update Count     : 295
 //
 
@@ -133 +133 @@
                         Value *lookup( Key *key, const std::list< TypeExpr* >& params ) const {
                                 TypeList typeList( params );
-                                
+
                                 // scan scopes for matches to the key
                                 for ( typename InnerMap::const_iterator insts = instantiations.find( key ); insts != instantiations.end(); insts = instantiations.findNext( insts, key ) ) {
@@ -160 +160 @@
                         virtual Declaration *mutate( UnionDecl *unionDecl );
                 };
-                
+
                 /// Replaces polymorphic return types with out-parameters, replaces calls to polymorphic functions with adapter calls as needed, and adds appropriate type variables to the function call
                 class Pass1 : public PolyMutator {
@@ -197 +197 @@
                         void addInferredParams( ApplicationExpr *appExpr, FunctionType *functionType, std::list< Expression *>::iterator &arg, const TyVarMap &tyVars );
                         /// Stores assignment operators from assertion list in local map of assignment operations
-                        void findAssignOps( const std::list< TypeDecl *> &forall );
+                        void findTypeOps( const std::list< TypeDecl *> &forall );
                         void passAdapters( ApplicationExpr *appExpr, FunctionType *functionType, const TyVarMap &exprTyVars );
                         FunctionDecl *makeAdapter( FunctionType *adaptee, FunctionType *realType, const std::string &mangleName, const TyVarMap &tyVars );
@@ -205 +205 @@
                         ObjectDecl *makeTemporary( Type *type );
 
-                        ScopedMap< std::string, DeclarationWithType *> assignOps;    ///< Currently known type variable assignment operators
+                        ScopedMap< std::string, DeclarationWithType* > assignOps;    ///< Currently known type variable assignment operators
+                        ScopedMap< std::string, DeclarationWithType* > ctorOps;      ///< Currently known type variable constructors
+                        ScopedMap< std::string, DeclarationWithType* > copyOps;      ///< Currently known type variable copy constructors
+                        ScopedMap< std::string, DeclarationWithType* > dtorOps;      ///< Currently known type variable destructors
                         ResolvExpr::TypeMap< DeclarationWithType > scopedAssignOps;  ///< Currently known assignment operators
+                        ResolvExpr::TypeMap< DeclarationWithType > scopedCtorOps;    ///< Currently known assignment operators
+                        ResolvExpr::TypeMap< DeclarationWithType > scopedCopyOps;    ///< Currently known assignment operators
+                        ResolvExpr::TypeMap< DeclarationWithType > scopedDtorOps;    ///< Currently known assignment operators
                         ScopedMap< std::string, DeclarationWithType* > adapters;     ///< Set of adapter functions in the current scope
-                        
+
                         DeclarationWithType *retval;
                         bool useRetval;
@@ -226 +232 @@
                         virtual Type *mutate( PointerType *pointerType );
                         virtual Type *mutate( FunctionType *funcType );
-                        
+
                   private:
                         void addAdapters( FunctionType *functionType );
@@ -297 +303 @@
                         /// Exits the type-variable scope
                         void endTypeScope();
-                        
+
                         ScopedSet< std::string > knownLayouts;          ///< Set of generic type layouts known in the current scope, indexed by sizeofName
                         ScopedSet< std::string > knownOffsets;          ///< Set of non-generic types for which the offset array exists in the current scope, indexed by offsetofName
@@ -351 +357 @@
                 PolyGenericCalculator polyCalculator;
                 Pass3 pass3;
-                
+
                 layoutBuilder.mutateDeclarationList( translationUnit );
                 mutateTranslationUnit/*All*/( translationUnit, pass1 );
@@ -370 +376 @@
                 return functionDecl;
         }
-        
+
         /// Get a list of type declarations that will affect a layout function
         std::list< TypeDecl* > takeOtypeOnly( std::list< TypeDecl* > &decls ) {
@@ -380 +386 @@
                         }
                 }
-                
+
                 return otypeDecls;
         }
@@ -387 +393 @@
         void addOtypeParams( FunctionType *layoutFnType, std::list< TypeDecl* > &otypeParams ) {
                 BasicType sizeAlignType( Type::Qualifiers(), BasicType::LongUnsignedInt );
-                
+
                 for ( std::list< TypeDecl* >::const_iterator param = otypeParams.begin(); param != otypeParams.end(); ++param ) {
                         TypeInstType paramType( Type::Qualifiers(), (*param)->get_name(), *param );
@@ -444 +450 @@
                 return makeCond( ifCond, ifExpr );
         }
-        
+
         /// adds an expression to a compound statement
         void addExpr( CompoundStmt *stmts, Expression *expr ) {
@@ -454 +460 @@
                 stmts->get_kids().push_back( stmt );
         }
-        
+
         Declaration *LayoutFunctionBuilder::mutate( StructDecl *structDecl ) {
                 // do not generate layout function for "empty" tag structs
@@ -467 +473 @@
                 BasicType *sizeAlignType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt );
                 PointerType *sizeAlignOutType = new PointerType( Type::Qualifiers(), sizeAlignType );
-                
+
                 ObjectDecl *sizeParam = new ObjectDecl( sizeofName( structDecl->get_name() ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType, 0 );
                 layoutFnType->get_parameters().push_back( sizeParam );
@@ -497 +503 @@
                                 addStmt( layoutDecl->get_statements(), makeAlignTo( derefVar( sizeParam ), new AlignofExpr( memberType->clone() ) ) );
                         }
-                        
+
                         // place current size in the current offset index
-                        addExpr( layoutDecl->get_statements(), makeOp( "?=?", makeOp( "?[?]", new VariableExpr( offsetParam ), new ConstantExpr( Constant::from( n_members ) ) ),
+                        addExpr( layoutDecl->get_statements(), makeOp( "?=?", makeOp( "?[?]", new VariableExpr( offsetParam ), new ConstantExpr( Constant::from_ulong( n_members ) ) ),
                                                                               derefVar( sizeParam ) ) );
                         ++n_members;
@@ -505 +511 @@
                         // add member size to current size
                         addExpr( layoutDecl->get_statements(), makeOp( "?+=?", derefVar( sizeParam ), new SizeofExpr( memberType->clone() ) ) );
-                        
+
                         // take max of member alignment and global alignment
                         addStmt( layoutDecl->get_statements(), makeAssignMax( derefVar( alignParam ), new AlignofExpr( memberType->clone() ) ) );
@@ -515 +521 @@
                 return structDecl;
         }
-        
+
         Declaration *LayoutFunctionBuilder::mutate( UnionDecl *unionDecl ) {
                 // do not generate layout function for "empty" tag unions
                 if ( unionDecl->get_members().empty() ) return unionDecl;
-                
+
                 // get parameters that can change layout, exiting early if none
                 std::list< TypeDecl* > otypeParams = takeOtypeOnly( unionDecl->get_parameters() );
@@ -528 +534 @@
                 BasicType *sizeAlignType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt );
                 PointerType *sizeAlignOutType = new PointerType( Type::Qualifiers(), sizeAlignType );
-                
+
                 ObjectDecl *sizeParam = new ObjectDecl( sizeofName( unionDecl->get_name() ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType, 0 );
                 layoutFnType->get_parameters().push_back( sizeParam );
@@ -545 +551 @@
                         assert( dwt );
                         Type *memberType = dwt->get_type();
-                        
+
                         // take max member size and global size
                         addStmt( layoutDecl->get_statements(), makeAssignMax( derefVar( sizeParam ), new SizeofExpr( memberType->clone() ) ) );
-                        
+
                         // take max of member alignment and global alignment
                         addStmt( layoutDecl->get_statements(), makeAssignMax( derefVar( alignParam ), new AlignofExpr( memberType->clone() ) ) );
@@ -558 +564 @@
                 return unionDecl;
         }
-        
+
         ////////////////////////////////////////// Pass1 ////////////////////////////////////////////////////
 
@@ -600 +606 @@
                 Pass1::Pass1() : useRetval( false ), tempNamer( "_temp" ) {}
 
-                /// Returns T if the given declaration is (*?=?)(T *, T) for some TypeInstType T (return not checked, but maybe should be), NULL otherwise
-                TypeInstType *isTypeInstAssignment( DeclarationWithType *decl ) {
-                        if ( decl->get_name() == "?=?" ) {
-                                if ( FunctionType *funType = getFunctionType( decl->get_type() ) ) {
-                                        if ( funType->get_parameters().size() == 2 ) {
-                                                if ( PointerType *pointer = dynamic_cast< PointerType *>( funType->get_parameters().front()->get_type() ) ) {
-                                                        if ( TypeInstType *refType = dynamic_cast< TypeInstType *>( pointer->get_base() ) ) {
-                                                                if ( TypeInstType *refType2 = dynamic_cast< TypeInstType *>( funType->get_parameters().back()->get_type() ) ) {
-                                                                        if ( refType->get_name() == refType2->get_name() ) {
-                                                                                return refType;
-                                                                        } // if
+                /// Returns T if the given declaration is a function with parameter (T*) for some TypeInstType T, NULL otherwise
+                TypeInstType *isTypeInstPtrFn( DeclarationWithType *decl ) {
+                        if ( FunctionType *funType = getFunctionType( decl->get_type() ) ) {
+                                if ( funType->get_parameters().size() == 1 ) {
+                                        if ( PointerType *pointer = dynamic_cast< PointerType *>( funType->get_parameters().front()->get_type() ) ) {
+                                                if ( TypeInstType *refType = dynamic_cast< TypeInstType *>( pointer->get_base() ) ) {
+                                                        return refType;
+                                                } // if
+                                        } // if
+                                } // if
+                        } // if
+                        return 0;
+                }
+                
+                /// Returns T if the given declaration is a function with parameters (T*, T) for some TypeInstType T, NULL otherwise
+                TypeInstType *isTypeInstPtrValFn( DeclarationWithType *decl ) {
+                        if ( FunctionType *funType = getFunctionType( decl->get_type() ) ) {
+                                if ( funType->get_parameters().size() == 2 ) {
+                                        if ( PointerType *pointer = dynamic_cast< PointerType *>( funType->get_parameters().front()->get_type() ) ) {
+                                                if ( TypeInstType *refType = dynamic_cast< TypeInstType *>( pointer->get_base() ) ) {
+                                                        if ( TypeInstType *refType2 = dynamic_cast< TypeInstType *>( funType->get_parameters().back()->get_type() ) ) {
+                                                                if ( refType->get_name() == refType2->get_name() ) {
+                                                                        return refType;
                                                                 } // if
                                                         } // if
@@ -620 +638 @@
                 }
                 
-                /// returns T if the given declaration is: (*?=?)(T *, T) for some type T (return not checked, but maybe should be), NULL otherwise
-                /// Only picks assignments where neither parameter is cv-qualified
-                Type *isAssignment( DeclarationWithType *decl ) {
-                        if ( decl->get_name() == "?=?" ) {
-                                if ( FunctionType *funType = getFunctionType( decl->get_type() ) ) {
-                                        if ( funType->get_parameters().size() == 2 ) {
-                                                Type::Qualifiers defaultQualifiers;
-                                                Type *paramType1 = funType->get_parameters().front()->get_type();
-                                                if ( paramType1->get_qualifiers() != defaultQualifiers ) return 0;
-                                                Type *paramType2 = funType->get_parameters().back()->get_type();
-                                                if ( paramType2->get_qualifiers() != defaultQualifiers ) return 0;
-                                                
-                                                if ( PointerType *pointerType = dynamic_cast< PointerType* >( paramType1 ) ) {
-                                                        Type *baseType1 = pointerType->get_base();
-                                                        if ( baseType1->get_qualifiers() != defaultQualifiers ) return 0;
-                                                        SymTab::Indexer dummy;
-                                                        if ( ResolvExpr::typesCompatible( baseType1, paramType2, dummy ) ) {
-                                                                return baseType1;
-                                                        } // if
+                /// Returns T if the given declaration is (*?=?)(T *, T) for some TypeInstType T (return not checked, but maybe should be), NULL otherwise
+                TypeInstType *isTypeInstAssignment( DeclarationWithType *decl ) {
+                        return decl->get_name() == "?=?" ? isTypeInstPtrValFn( decl ) : 0;
+                }
+
+                /// Returns T if the given declaration is (*?{})(T *) for some TypeInstType T (return not checked, but maybe should be), NULL otherwise
+                TypeInstType *isTypeInstCtor( DeclarationWithType *decl ) {
+                        return decl->get_name() == "?{}" ? isTypeInstPtrFn( decl ) : 0;
+                }
+
+                /// Returns T if the given declaration is (*?{})(T *, T) for some TypeInstType T (return not checked, but maybe should be), NULL otherwise
+                TypeInstType *isTypeInstCopy( DeclarationWithType *decl ) {
+                        return decl->get_name() == "?{}" ? isTypeInstPtrValFn( decl ) : 0;
+                }
+
+                /// Returns T if the given declaration is (*^?{})(T *) for some TypeInstType T (return not checked, but maybe should be), NULL otherwise
+                TypeInstType *isTypeInstDtor( DeclarationWithType *decl ) {
+                        return decl->get_name() == "^?{}" ? isTypeInstPtrFn( decl ) : 0;
+                }
+
+                /// Returns T if the given declaration is a function with parameters (T*, T) for some type T, where neither parameter is cv-qualified,
+                /// NULL otherwise
+                Type *isNoCvPtrFn( DeclarationWithType *decl ) {
+                        if ( FunctionType *funType = getFunctionType( decl->get_type() ) ) {
+                                if ( funType->get_parameters().size() == 1 ) {
+                                        Type::Qualifiers defaultQualifiers;
+                                        Type *paramType = funType->get_parameters().front()->get_type();
+                                        if ( paramType->get_qualifiers() != defaultQualifiers ) return 0;
+
+                                        if ( PointerType *pointerType = dynamic_cast< PointerType* >( paramType ) ) {
+                                                Type *baseType = pointerType->get_base();
+                                                if ( baseType->get_qualifiers() == defaultQualifiers ) {
+                                                        return baseType;
                                                 } // if
                                         } // if
@@ -645 +677 @@
                         return 0;
                 }
-
-                void Pass1::findAssignOps( const std::list< TypeDecl *> &forall ) {
+                
+                /// Returns T if the given declaration is a function with parameters (T*, T) for some type T, where neither parameter is cv-qualified,
+                /// NULL otherwise
+                Type *isNoCvPtrValFn( DeclarationWithType *decl ) {
+                        if ( FunctionType *funType = getFunctionType( decl->get_type() ) ) {
+                                if ( funType->get_parameters().size() == 2 ) {
+                                        Type::Qualifiers defaultQualifiers;
+                                        Type *paramType1 = funType->get_parameters().front()->get_type();
+                                        if ( paramType1->get_qualifiers() != defaultQualifiers ) return 0;
+                                        Type *paramType2 = funType->get_parameters().back()->get_type();
+                                        if ( paramType2->get_qualifiers() != defaultQualifiers ) return 0;
+
+                                        if ( PointerType *pointerType = dynamic_cast< PointerType* >( paramType1 ) ) {
+                                                Type *baseType1 = pointerType->get_base();
+                                                if ( baseType1->get_qualifiers() != defaultQualifiers ) return 0;
+                                                SymTab::Indexer dummy;
+                                                if ( ResolvExpr::typesCompatible( baseType1, paramType2, dummy ) ) {
+                                                        return baseType1;
+                                                } // if
+                                        } // if
+                                } // if
+                        } // if
+                        return 0;
+                }
+
+                /// returns T if the given declaration is: (*?=?)(T *, T) for some type T (return not checked, but maybe should be), NULL otherwise
+                /// Only picks assignments where neither parameter is cv-qualified
+                Type *isAssignment( DeclarationWithType *decl ) {
+                        return decl->get_name() == "?=?" ? isNoCvPtrValFn( decl ) : 0;
+                }
+
+                /// returns T if the given declaration is: (*?{})(T *) for some type T, NULL otherwise
+                /// Only picks ctors where the parameter is not cv-qualified
+                Type *isCtor( DeclarationWithType *decl ) {
+                        return decl->get_name() == "?{}" ? isNoCvPtrFn( decl ) : 0;
+                }
+
+                /// returns T if the given declaration is: (*?{})(T *, T) for some type T (return not checked, but maybe should be), NULL otherwise
+                /// Only picks copy constructors where neither parameter is cv-qualified
+                Type *isCopy( DeclarationWithType *decl ) {
+                        return decl->get_name() == "?{}" ? isNoCvPtrValFn( decl ) : 0;
+                }
+
+                /// returns T if the given declaration is: (*?{})(T *) for some type T, NULL otherwise
+                /// Only picks ctors where the parameter is not cv-qualified
+                Type *isDtor( DeclarationWithType *decl ) {
+                        return decl->get_name() == "^?{}" ? isNoCvPtrFn( decl ) : 0;
+                }
+
+                void Pass1::findTypeOps( const std::list< TypeDecl *> &forall ) {
                         // what if a nested function uses an assignment operator?
                         // assignOps.clear();
@@ -654 +734 @@
                                         if ( TypeInstType *typeInst = isTypeInstAssignment( *assert ) ) {
                                                 assignOps[ typeInst->get_name() ] = *assert;
+                                        } else if ( TypeInstType *typeInst = isTypeInstCtor( *assert ) ) {
+                                                ctorOps[ typeInst->get_name() ] = *assert;
+                                        } else if ( TypeInstType *typeInst = isTypeInstCopy( *assert ) ) {
+                                                copyOps[ typeInst->get_name() ] = *assert;
+                                        } else if ( TypeInstType *typeInst = isTypeInstDtor( *assert ) ) {
+                                                dtorOps[ typeInst->get_name() ] = *assert;
                                         } // if
                                 } // for
@@ -661 +747 @@
                 DeclarationWithType *Pass1::mutate( FunctionDecl *functionDecl ) {
                         // if this is a assignment function, put it in the map for this scope
-                        if ( Type *assignedType = isAssignment( functionDecl ) ) {
-                                if ( ! dynamic_cast< TypeInstType* >( assignedType ) ) {
-                                        scopedAssignOps.insert( assignedType, functionDecl );
+                        if ( Type *paramType = isAssignment( functionDecl ) ) {
+                                if ( ! dynamic_cast< TypeInstType* >( paramType ) ) {
+                                        scopedAssignOps.insert( paramType, functionDecl );
+                                }
+                        } else if ( Type *paramType = isCtor( functionDecl ) ) {
+                                if ( ! dynamic_cast< TypeInstType* >( paramType ) ) {
+                                        scopedCtorOps.insert( paramType, functionDecl );
+                                }
+                        } else if ( Type *paramType = isCopy( functionDecl ) ) {
+                                if ( ! dynamic_cast< TypeInstType* >( paramType ) ) {
+                                        scopedCopyOps.insert( paramType, functionDecl );
+                                }
+                        } else if ( Type *paramType = isDtor( functionDecl ) ) {
+                                if ( ! dynamic_cast< TypeInstType* >( paramType ) ) {
+                                        scopedDtorOps.insert( paramType, functionDecl );
                                 }
                         }
@@ -671 +769 @@
                                 scopeTyVars.beginScope();
                                 assignOps.beginScope();
+                                ctorOps.beginScope();
+                                copyOps.beginScope();
+                                dtorOps.beginScope();
+                                
                                 DeclarationWithType *oldRetval = retval;
                                 bool oldUseRetval = useRetval;
@@ -688 +790 @@
                                 FunctionType *functionType = functionDecl->get_functionType();
                                 makeTyVarMap( functionDecl->get_functionType(), scopeTyVars );
-                                findAssignOps( functionDecl->get_functionType()->get_forall() );
+                                findTypeOps( functionDecl->get_functionType()->get_forall() );
 
                                 std::list< DeclarationWithType *> &paramList = functionType->get_parameters();
@@ -713 +815 @@
                                 scopeTyVars.endScope();
                                 assignOps.endScope();
+                                ctorOps.endScope();
+                                copyOps.endScope();
+                                dtorOps.endScope();
                                 retval = oldRetval;
                                 useRetval = oldUseRetval;
@@ -784 +889 @@
                                                 arg++;
                                         } else {
-                                                throw SemanticError( "unbound type variable in application ", appExpr );
+                                                /// xxx - should this be an assertion?
+                                                throw SemanticError( "unbound type variable: " + tyParm->first + " in application ", appExpr );
                                         } // if
                                 } // if
@@ -803 +909 @@
                                 passArgTypeVars( appExpr, polyRetType, concRetType, arg, exprTyVars, seenTypes );
                         }
-                        
+
                         // add type information args for presently unseen types in parameter list
                         for ( ; fnParm != funcType->get_parameters().end() && fnArg != appExpr->get_args().end(); ++fnParm, ++fnArg ) {
@@ -882 +988 @@
                         assert( env );
                         Type *concrete = replaceWithConcrete( appExpr, polyType );
-                        // add out-parameter for return value   
+                        // add out-parameter for return value
                         return addRetParam( appExpr, function, concrete, arg );
                 }
@@ -910 +1016 @@
                                 } else if ( arg->get_results().front()->get_isLvalue() ) {
                                         // VariableExpr and MemberExpr are lvalues; need to check this isn't coming from the second arg of a comma expression though (not an lvalue)
+                                        // xxx - need to test that this code is still reachable
                                         if ( CommaExpr *commaArg = dynamic_cast< CommaExpr* >( arg ) ) {
                                                 commaArg->set_arg2( new AddressExpr( commaArg->get_arg2() ) );
@@ -1035 +1142 @@
                         std::list< DeclarationWithType *>::iterator param = adapterType->get_parameters().begin();
                         std::list< DeclarationWithType *>::iterator realParam = adaptee->get_parameters().begin();
-                        param++;                // skip adaptee parameter
+                        param++;                // skip adaptee parameter in the adapter type
                         if ( realType->get_returnVals().empty() ) {
+                                // void return
                                 addAdapterParams( adapteeApp, arg, param, adapterType->get_parameters().end(), realParam, tyVars );
                                 bodyStmt = new ExprStmt( noLabels, adapteeApp );
                         } else if ( isPolyType( adaptee->get_returnVals().front()->get_type(), tyVars ) ) {
+                                // return type T
                                 if ( (*param)->get_name() == "" ) {
                                         (*param)->set_name( "_ret" );
@@ -1291 +1400 @@
                         } else if ( needsAdapter( function, scopeTyVars ) ) {
                                 // std::cerr << "needs adapter: ";
-                                // for ( TyVarMap::iterator i = scopeTyVars.begin(); i != scopeTyVars.end(); ++i ) {
-                                //      std::cerr << i->first << " ";
-                                // }
-                                // std::cerr << "\n";
+                                // printTyVarMap( std::cerr, scopeTyVars );
+                                // std::cerr << *env << std::endl;
                                 // change the application so it calls the adapter rather than the passed function
                                 ret = applyAdapter( appExpr, function, arg, scopeTyVars );
@@ -1345 +1452 @@
                                 } // if
                         } // if
+                        // isPolyType check needs to happen before mutating addrExpr arg, so pull it forward
+                        // out of the if condition.
+                        bool polytype = isPolyType( addrExpr->get_arg()->get_results().front(), scopeTyVars, env );
                         addrExpr->set_arg( mutateExpression( addrExpr->get_arg() ) );
-                        if ( isPolyType( addrExpr->get_arg()->get_results().front(), scopeTyVars, env ) || needs ) {
+                        if ( polytype || needs ) {
                                 Expression *ret = addrExpr->get_arg();
                                 delete ret->get_results().front();
@@ -1365 +1475 @@
                         functionObj->set_mangleName( functionDecl->get_mangleName() );
                         return new VariableExpr( functionObj );
+                }
+
+                /// Finds the operation declaration for a given type in one of the two maps
+                DeclarationWithType* findOpForType( Type *formalType, const ScopedMap< std::string, DeclarationWithType* >& ops, ResolvExpr::TypeMap< DeclarationWithType >& scopedOps ) {
+                        if ( TypeInstType *formalTypeInstType = dynamic_cast< TypeInstType* >( formalType ) ) {
+                                ScopedMap< std::string, DeclarationWithType *>::const_iterator opIt = ops.find( formalTypeInstType->get_name() );
+                                return opIt == ops.end() ? 0 : opIt->second;
+                        } else {
+                                return scopedOps.find( formalType );
+                        }
+                }
+
+                /// Adds an assertion parameter to the application expression for the actual assertion declaration valued with the assert op
+                void addAssertionFor( ApplicationExpr *appExpr, DeclarationWithType *actualDecl, DeclarationWithType *assertOp ) {
+                        appExpr->get_inferParams()[ actualDecl->get_uniqueId() ]
+                                        = ParamEntry( assertOp->get_uniqueId(), assertOp->get_type()->clone(), actualDecl->get_type()->clone(), wrapFunctionDecl( assertOp ) );
                 }
                 
@@ -1413 +1539 @@
                                                 assignExpr->get_env()->add( (*forallIt)->get_name(), formalType );
 
-                                                // skip types with no assign op (ftype/dtype)
+                                                // skip non-otype parameters (ftype/dtype)
                                                 if ( (*forallIt)->get_kind() != TypeDecl::Any ) continue;
 
-                                                // find assignment operator for formal type
-                                                DeclarationWithType *assertAssign = 0;
-                                                if ( TypeInstType *formalTypeInstType = dynamic_cast< TypeInstType* >( formalType ) ) {
-                                                        ScopedMap< std::string, DeclarationWithType *>::const_iterator assertAssignIt = assignOps.find( formalTypeInstType->get_name() );
-                                                        if ( assertAssignIt == assignOps.end() ) {
-                                                                throw SemanticError( "No assignment operation found for ", formalTypeInstType );
-                                                        }
-                                                        assertAssign = assertAssignIt->second;
-                                                } else {
-                                                        assertAssign = scopedAssignOps.find( formalType );
-                                                        if ( ! assertAssign ) {
-                                                                throw SemanticError( "No assignment operation found for ", formalType );
-                                                        }
-                                                }
-
-                                                // add inferred parameter for field assignment operator to assignment expression
+                                                // find otype operators for formal type
+                                                DeclarationWithType *assertAssign = findOpForType( formalType, assignOps, scopedAssignOps );
+                                                if ( ! assertAssign ) throw SemanticError( "No assignment operation found for ", formalType );
+
+                                                DeclarationWithType *assertCtor = findOpForType( formalType, ctorOps, scopedCtorOps );
+                                                if ( ! assertCtor ) throw SemanticError( "No default constructor found for ", formalType );
+
+                                                DeclarationWithType *assertCopy = findOpForType( formalType, copyOps, scopedCopyOps );
+                                                if ( ! assertCopy ) throw SemanticError( "No copy constructor found for ", formalType );
+
+                                                DeclarationWithType *assertDtor = findOpForType( formalType, dtorOps, scopedDtorOps );
+                                                if ( ! assertDtor ) throw SemanticError( "No destructor found for ", formalType );
+                                                
+                                                // add inferred parameters for otype operators to assignment expression
+                                                // NOTE: Code here assumes that first four assertions are assign op, ctor, copy ctor, dtor, in that order
                                                 std::list< DeclarationWithType* > &asserts = (*forallIt)->get_assertions();
-                                                assert( ! asserts.empty() && "Type param needs assignment operator assertion" );
-                                                DeclarationWithType *actualDecl = asserts.front();
-                                                assignExpr->get_inferParams()[ actualDecl->get_uniqueId() ]
-                                                        = ParamEntry( assertAssign->get_uniqueId(), assertAssign->get_type()->clone(), actualDecl->get_type()->clone(), wrapFunctionDecl( assertAssign ) );
+                                                assert( asserts.size() >= 4 && "Type param needs otype operator assertions" );
+
+                                                std::list< DeclarationWithType* >::iterator actualIt = asserts.begin();
+                                                addAssertionFor( assignExpr, *actualIt, assertAssign );
+                                                ++actualIt;
+                                                addAssertionFor( assignExpr, *actualIt, assertCtor );
+                                                ++actualIt;
+                                                addAssertionFor( assignExpr, *actualIt, assertCopy );
+                                                ++actualIt;
+                                                addAssertionFor( assignExpr, *actualIt, assertDtor );
+                                                
+                                                //DeclarationWithType *actualDecl = asserts.front();
+                                                //assignExpr->get_inferParams()[ actualDecl->get_uniqueId() ]
+                                                //      = ParamEntry( assertAssign->get_uniqueId(), assertAssign->get_type()->clone(), actualDecl->get_type()->clone(), wrapFunctionDecl( assertAssign ) );
                                         }
                                 }
@@ -1482 +1617 @@
                         adapters.beginScope();
                         scopedAssignOps.beginScope();
+                        scopedCtorOps.beginScope();
+                        scopedCopyOps.beginScope();
+                        scopedDtorOps.beginScope();
                 }
 
@@ -1487 +1625 @@
                         adapters.endScope();
                         scopedAssignOps.endScope();
+                        scopedCtorOps.endScope();
+                        scopedCopyOps.endScope();
+                        scopedDtorOps.endScope();
                 }
 
@@ -1886 +2027 @@
                                 }
                         }
-                        
+
                         Type *ret = Mutator::mutate( funcType );
 
@@ -1905 +2046 @@
 
                                         std::list<Expression*> designators;
-                                        objectDecl->set_init( new SingleInit( alloc, designators ) );
+                                        objectDecl->set_init( new SingleInit( alloc, designators, false ) ); // not constructed
                                 }
                         }
@@ -1942 +2083 @@
                                 UntypedExpr *derefExpr = new UntypedExpr( new NameExpr( "*?" ) );
                                 derefExpr->get_args().push_back( derefdVar );
+                                // xxx - should set results on derefExpr
                                 derefdVar = derefExpr;
                         }
                         return derefdVar;
                 }
-                
+
                 Expression *PolyGenericCalculator::mutate( MemberExpr *memberExpr ) {
                         // mutate, exiting early if no longer MemberExpr
@@ -2038 +2180 @@
 
                 bool PolyGenericCalculator::findGeneric( Type *ty ) {
+                        ty = replaceTypeInst( ty, env );
+                        
                         if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( ty ) ) {
-                                // duplicate logic from isPolyType()
-                                if ( env ) {
-                                        if ( Type *newType = env->lookup( typeInst->get_name() ) ) {
-                                                return findGeneric( newType );
-                                        } // if
-                                } // if
                                 if ( scopeTyVars.find( typeInst->get_name() ) != scopeTyVars.end() ) {
                                         // NOTE assumes here that getting put in the scopeTyVars included having the layout variables set
@@ -2066 +2204 @@
                                 if ( n_members == 0 ) {
                                         // all empty structs have the same layout - size 1, align 1
-                                        makeVar( sizeofName( typeName ), layoutType, new SingleInit( new ConstantExpr( Constant::from( (unsigned long)1 ) ) ) );
-                                        makeVar( alignofName( typeName ), layoutType->clone(), new SingleInit( new ConstantExpr( Constant::from( (unsigned long)1 ) ) ) );
+                                        makeVar( sizeofName( typeName ), layoutType, new SingleInit( new ConstantExpr( Constant::from_ulong( (unsigned long)1 ) ) ) );
+                                        makeVar( alignofName( typeName ), layoutType->clone(), new SingleInit( new ConstantExpr( Constant::from_ulong( (unsigned long)1 ) ) ) );
                                         // NOTE zero-length arrays are forbidden in C, so empty structs have no offsetof array
                                 } else {
                                         ObjectDecl *sizeVar = makeVar( sizeofName( typeName ), layoutType );
                                         ObjectDecl *alignVar = makeVar( alignofName( typeName ), layoutType->clone() );
-                                        ObjectDecl *offsetVar = makeVar( offsetofName( typeName ), new ArrayType( Type::Qualifiers(), layoutType->clone(), new ConstantExpr( Constant::from( n_members ) ), false, false ) );
+                                        ObjectDecl *offsetVar = makeVar( offsetofName( typeName ), new ArrayType( Type::Qualifiers(), layoutType->clone(), new ConstantExpr( Constant::from_int( n_members ) ), false, false ) );
 
                                         // generate call to layout function
@@ -2144 +2282 @@
                         Type *ty = offsetofExpr->get_type();
                         if ( ! findGeneric( ty ) ) return offsetofExpr;
-                        
+
                         if ( StructInstType *structType = dynamic_cast< StructInstType* >( ty ) ) {
                                 // replace offsetof expression by index into offset array
@@ -2191 +2329 @@
 
                                         // build the offset array and replace the pack with a reference to it
-                                        ObjectDecl *offsetArray = makeVar( offsetName, new ArrayType( Type::Qualifiers(), offsetType, new ConstantExpr( Constant::from( baseMembers.size() ) ), false, false ),
+                                        ObjectDecl *offsetArray = makeVar( offsetName, new ArrayType( Type::Qualifiers(), offsetType, new ConstantExpr( Constant::from_ulong( baseMembers.size() ) ), false, false ),
                                                         new ListInit( inits ) );
                                         ret = new VariableExpr( offsetArray );