Changeset 67cf18c for src/SymTab/Validate.cc

Timestamp:

May 26, 2017, 6:37:49 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:

01b9928

Parents:

ff03f5c

git-author:

Rob Schluntz <rschlunt@…> (05/26/17 18:34:50)

git-committer:

Rob Schluntz <rschlunt@…> (05/26/17 18:37:49)

Message:

implement default type arguments for generic types [closes #13]

File:

• src/SymTab/Validate.cc (modified) (2 diffs)

src/SymTab/Validate.cc

@@ -506 +506 @@
         void LinkReferenceToTypes::visit( StructDecl *structDecl ) {
                 // visit struct members first so that the types of self-referencing members are updated properly
+                // xxx - need to ensure that type parameters match up between forward declarations and definition (most importantly, number of type parameters and and their defaults)
                 Parent::visit( structDecl );
                 if ( ! structDecl->get_members().empty() ) {
@@ -844 +845 @@
                 if ( params != NULL ) {
                         std::list< Expression * > & args = inst->get_parameters();
+
+                        // insert defaults arguments when a type argument is missing (currently only supports missing arguments at the end of the list).
+                        // A substitution is used to ensure that defaults are replaced correctly, e.g.,
+                        //   forall(otype T, otype alloc = heap_allocator(T)) struct vector;
+                        //   vector(int) v;
+                        // after insertion of default values becomes
+                        //   vector(int, heap_allocator(T))
+                        // and the substitution is built with T=int so that after substitution, the result is
+                        //   vector(int, heap_allocator(int))
+                        TypeSubstitution sub;
+                        auto paramIter = params->begin();
+                        for ( size_t i = 0; paramIter != params->end(); ++paramIter, ++i ) {
+                                if ( i < args.size() ) {
+                                        TypeExpr * expr = safe_dynamic_cast< TypeExpr * >( *std::next( args.begin(), i ) );
+                                        sub.add( (*paramIter)->get_name(), expr->get_type()->clone() );
+                                } else if ( i == args.size() ) {
+                                        Type * defaultType = (*paramIter)->get_init();
+                                        if ( defaultType ) {
+                                                args.push_back( new TypeExpr( defaultType->clone() ) );
+                                                sub.add( (*paramIter)->get_name(), defaultType->clone() );
+                                        }
+                                }
+                        }
+
+                        sub.apply( inst );
                         if ( args.size() < params->size() ) throw SemanticError( "Too few type arguments in generic type ", inst );
                         if ( args.size() > params->size() ) throw SemanticError( "Too many type arguments in generic type ", inst );