Changeset c0d00b6 for src/SymTab

Timestamp:

Nov 25, 2017, 3:22:18 PM (6 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, arm-eh, ast-experimental, cleanup-dtors, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

c6e2c18

Parents:

9d06142 (diff), 3de176d (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' into cleanup-dtors

Location:

src/SymTab

Files:

• Autogen.cc (modified) (5 diffs)
• Autogen.h (modified) (6 diffs)
• Indexer.cc (modified) (1 diff)
• Indexer.h (modified) (1 diff)
• Validate.cc (modified) (9 diffs)

src/SymTab/Autogen.cc

@@ -62 +62 @@
                 void previsit( FunctionDecl * functionDecl );
 
-                void previsit( FunctionType * ftype );
-                void previsit( PointerType * ptype );
-
                 void previsit( CompoundStmt * compoundStmt );
 
@@ -72 +69 @@
                 unsigned int functionNesting = 0;     // current level of nested functions
 
-                InitTweak::ManagedTypes managedTypes;
                 std::vector< FuncData > data;
         };
@@ -625 +621 @@
         // generate ctor/dtors/assign for typedecls, e.g., otype T = int *;
         void AutogenerateRoutines::previsit( TypeDecl * typeDecl ) {
-                visit_children = false;
                 if ( ! typeDecl->base ) return;
 
@@ -631 +626 @@
                 TypeFuncGenerator gen( typeDecl, &refType, data, functionNesting, indexer );
                 generateFunctions( gen, declsToAddAfter );
-        }
-
-        void AutogenerateRoutines::previsit( FunctionType *) {
-                // ensure that we don't add assignment ops for types defined as part of the function
-                visit_children = false;
-        }
-
-        void AutogenerateRoutines::previsit( PointerType *) {
-                // ensure that we don't add assignment ops for types defined as part of the pointer
-                visit_children = false;
+
         }
 
@@ -648 +634 @@
         }
 
-        void AutogenerateRoutines::previsit( FunctionDecl * functionDecl ) {
-                visit_children = false;
-                // record the existence of this function as appropriate
-                managedTypes.handleDWT( functionDecl );
-
-                maybeAccept( functionDecl->type, *visitor );
+        void AutogenerateRoutines::previsit( FunctionDecl * ) {
+                // Track whether we're currently in a function.
+                // Can ignore function type idiosyncrasies, because function type can never
+                // declare a new type.
                 functionNesting += 1;
-                maybeAccept( functionDecl->statements, *visitor );
-                functionNesting -= 1;
+                GuardAction( [this]()  { functionNesting -= 1; } );
         }
 
         void AutogenerateRoutines::previsit( CompoundStmt * ) {
-                GuardScope( managedTypes );
                 GuardScope( structsDone );
         }

src/SymTab/Autogen.h

@@ -59 +59 @@
         /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls.
         template< typename OutputIterator >
-        Statement * genCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, bool addCast = false, bool forward = true );
+        Statement * genCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, Type * addCast = nullptr, bool forward = true );
 
         /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Should only be called with non-array types.
         /// optionally returns a statement which must be inserted prior to the containing loop, if there is one
         template< typename OutputIterator >
-        Statement * genScalarCall( InitTweak::InitExpander & srcParam, Expression * dstParam, std::string fname, OutputIterator out, Type * type, bool addCast = false ) {
+        Statement * genScalarCall( InitTweak::InitExpander & srcParam, Expression * dstParam, std::string fname, OutputIterator out, Type * type, Type * addCast = nullptr ) {
                 bool isReferenceCtorDtor = false;
                 if ( dynamic_cast< ReferenceType * >( type ) && CodeGen::isCtorDtor( fname ) ) {
@@ -71 +71 @@
                         fname = "?=?";
                         dstParam = new AddressExpr( dstParam );
-                        addCast = false;
+                        addCast = nullptr;
                         isReferenceCtorDtor = true;
                 }
@@ -86 +86 @@
                         // remove lvalue as a qualifier, this can change to
                         //   type->get_qualifiers() = Type::Qualifiers();
-                        assert( type );
-                        Type * castType = type->clone();
+                        Type * castType = addCast->clone();
                         castType->get_qualifiers() -= Type::Qualifiers( Type::Lvalue | Type::Const | Type::Volatile | Type::Restrict | Type::Atomic );
                         // castType->set_lvalue( true ); // xxx - might not need this
@@ -118 +117 @@
         /// If forward is true, loop goes from 0 to N-1, else N-1 to 0
         template< typename OutputIterator >
-        void genArrayCall( InitTweak::InitExpander & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, ArrayType *array, bool addCast = false, bool forward = true ) {
+        void genArrayCall( InitTweak::InitExpander & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, ArrayType *array, Type * addCast = nullptr, bool forward = true ) {
                 static UniqueName indexName( "_index" );
 
                 // for a flexible array member nothing is done -- user must define own assignment
-                if ( ! array->get_dimension() ) return ;
+                if ( ! array->get_dimension() ) return;
+
+                if ( addCast ) {
+                        // peel off array layer from cast
+                        ArrayType * at = strict_dynamic_cast< ArrayType * >( addCast );
+                        addCast = at->base;
+                }
 
                 Expression * begin, * end, * update, * cmp;
@@ -174 +179 @@
 
         template< typename OutputIterator >
-        Statement * genCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, bool addCast, bool forward ) {
+        Statement * genCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, Type * addCast, bool forward ) {
                 if ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) {
                         genArrayCall( srcParam, dstParam, fname, out, at, addCast, forward );
@@ -194 +199 @@
                 if ( isUnnamedBitfield( obj ) ) return;
 
-                bool addCast = (fname == "?{}" || fname == "^?{}") && ( !obj || ( obj && ! obj->get_bitfieldWidth() ) );
+                Type * addCast = nullptr;
+                if ( (fname == "?{}" || fname == "^?{}") && ( !obj || ( obj && ! obj->get_bitfieldWidth() ) ) ) {
+                        assert( dstParam->result );
+                        addCast = dstParam->result;
+                }
                 std::list< Statement * > stmts;
                 genCall( srcParam, dstParam, fname, back_inserter( stmts ), obj->type, addCast, forward );

src/SymTab/Indexer.cc

@@ -567 +567 @@
         }
 
+        void Indexer::addIds( const std::list< DeclarationWithType * > & decls ) {
+                for ( auto d : decls ) {
+                        addId( d );
+                }
+        }
+
+        void Indexer::addTypes( const std::list< TypeDecl * > & tds ) {
+                for ( auto td : tds ) {
+                        addType( td );
+                        addIds( td->assertions );
+                }
+        }
+
+        void Indexer::addFunctionType( FunctionType * ftype ) {
+                addTypes( ftype->forall );
+                addIds( ftype->returnVals );
+                addIds( ftype->parameters );
+        }
+
         void Indexer::enterScope() {
                 ++scope;

src/SymTab/Indexer.h

@@ -76 +76 @@
                 void addTrait( TraitDecl *decl );
 
+                /// convenience function for adding a list of Ids to the indexer
+                void addIds( const std::list< DeclarationWithType * > & decls );
+
+                /// convenience function for adding a list of forall parameters to the indexer
+                void addTypes( const std::list< TypeDecl * > & tds );
+
+                /// convenience function for adding all of the declarations in a function type to the indexer
+                void addFunctionType( FunctionType * ftype );
+
                 bool doDebug = false; ///< Display debugging trace?
           private:

src/SymTab/Validate.cc

@@ -124 +124 @@
 
         /// Associates forward declarations of aggregates with their definitions
-        struct LinkReferenceToTypes final : public WithIndexer {
+        struct LinkReferenceToTypes final : public WithIndexer, public WithGuards {
                 LinkReferenceToTypes( const Indexer *indexer );
                 void postvisit( TypeInstType *typeInst );
@@ -137 +137 @@
                 void postvisit( UnionDecl *unionDecl );
                 void postvisit( TraitDecl * traitDecl );
+
+                void previsit( StructDecl *structDecl );
+                void previsit( UnionDecl *unionDecl );
+
+                void renameGenericParams( std::list< TypeDecl * > & params );
 
           private:
@@ -147 +152 @@
                 ForwardStructsType forwardStructs;
                 ForwardUnionsType forwardUnions;
+                /// true if currently in a generic type body, so that type parameter instances can be renamed appropriately
+                bool inGeneric = false;
         };
 
@@ -423 +430 @@
         }
 
+        void checkGenericParameters( ReferenceToType * inst ) {
+                for ( Expression * param : inst->parameters ) {
+                        if ( ! dynamic_cast< TypeExpr * >( param ) ) {
+                                throw SemanticError( "Expression parameters for generic types are currently unsupported: ", inst );
+                        }
+                }
+        }
+
         void LinkReferenceToTypes::postvisit( StructInstType *structInst ) {
                 StructDecl *st = local_indexer->lookupStruct( structInst->get_name() );
@@ -434 +449 @@
                         forwardStructs[ structInst->get_name() ].push_back( structInst );
                 } // if
+                checkGenericParameters( structInst );
         }
 
@@ -446 +462 @@
                         forwardUnions[ unionInst->get_name() ].push_back( unionInst );
                 } // if
+                checkGenericParameters( unionInst );
         }
 
@@ -525 +542 @@
                 // need to carry over the 'sized' status of each decl in the instance
                 for ( auto p : group_iterate( traitDecl->get_parameters(), traitInst->get_parameters() ) ) {
-                        TypeExpr * expr = strict_dynamic_cast< TypeExpr * >( std::get<1>(p) );
+                        TypeExpr * expr = dynamic_cast< TypeExpr * >( std::get<1>(p) );
+                        if ( ! expr ) {
+                                throw SemanticError( "Expression parameters for trait instances are currently unsupported: ", std::get<1>(p) );
+                        }
                         if ( TypeInstType * inst = dynamic_cast< TypeInstType * >( expr->get_type() ) ) {
                                 TypeDecl * formalDecl = std::get<0>(p);
@@ -546 +566 @@
                         } // if
                 } // if
+        }
+
+        void LinkReferenceToTypes::renameGenericParams( std::list< TypeDecl * > & params ) {
+                // rename generic type parameters uniquely so that they do not conflict with user-defined function forall parameters, e.g.
+                //   forall(otype T)
+                //   struct Box {
+                //     T x;
+                //   };
+                //   forall(otype T)
+                //   void f(Box(T) b) {
+                //     ...
+                //   }
+                // The T in Box and the T in f are different, so internally the naming must reflect that.
+                GuardValue( inGeneric );
+                inGeneric = ! params.empty();
+                for ( TypeDecl * td : params ) {
+                        td->name = "__" + td->name + "_generic_";
+                }
+        }
+
+        void LinkReferenceToTypes::previsit( StructDecl * structDecl ) {
+                renameGenericParams( structDecl->parameters );
+        }
+
+        void LinkReferenceToTypes::previsit( UnionDecl * unionDecl ) {
+                renameGenericParams( unionDecl->parameters );
         }
 
@@ -575 +621 @@
 
         void LinkReferenceToTypes::postvisit( TypeInstType *typeInst ) {
+                // ensure generic parameter instances are renamed like the base type
+                if ( inGeneric && typeInst->baseType ) typeInst->name = typeInst->baseType->name;
                 if ( NamedTypeDecl *namedTypeDecl = local_indexer->lookupType( typeInst->get_name() ) ) {
                         if ( TypeDecl *typeDecl = dynamic_cast< TypeDecl * >( namedTypeDecl ) ) {