Changes in src/SymTab/Validate.cc [b3b2077:9facf3b]

File:

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

src/SymTab/Validate.cc

@@ -61 +61 @@
 #include <algorithm>
 #include "InitTweak/InitTweak.h"
+#include "CodeGen/CodeGenerator.h"
 
 #define debugPrint( x ) if ( doDebug ) { std::cout << x; }
 
 namespace SymTab {
-        class HoistStruct : public Visitor {
+        class HoistStruct final : public Visitor {
           public:
                 /// Flattens nested struct types
@@ -86 +87 @@
         };
 
+        /// Fix return types so that every function returns exactly one value
+        class ReturnTypeFixer final : public Visitor {
+          public:
+
+                typedef Visitor Parent;
+                using Parent::visit;
+
+                static void fix( std::list< Declaration * > &translationUnit );
+
+                virtual void visit( FunctionDecl * functionDecl );
+
+                virtual void visit( FunctionType * ftype );
+        };
+
         /// Replaces enum types by int, and function or array types in function parameter and return lists by appropriate pointers.
-        class EnumAndPointerDecayPass : public Visitor {
+        class EnumAndPointerDecayPass final : public Visitor {
                 typedef Visitor Parent;
                 virtual void visit( EnumDecl *aggregateDecl );
@@ -94 +109 @@
 
         /// Associates forward declarations of aggregates with their definitions
-        class Pass2 : public Indexer {
+        class LinkReferenceToTypes final : public Indexer {
                 typedef Indexer Parent;
           public:
-                Pass2( bool doDebug, const Indexer *indexer );
+                LinkReferenceToTypes( bool doDebug, const Indexer *indexer );
           private:
-                virtual void visit( StructInstType *structInst );
-                virtual void visit( UnionInstType *unionInst );
-                virtual void visit( TraitInstType *contextInst );
-                virtual void visit( StructDecl *structDecl );
-                virtual void visit( UnionDecl *unionDecl );
-                virtual void visit( TypeInstType *typeInst );
+                using Indexer::visit;
+                void visit( StructInstType *structInst ) final;
+                void visit( UnionInstType *unionInst ) final;
+                void visit( TraitInstType *contextInst ) final;
+                void visit( StructDecl *structDecl ) final;
+                void visit( UnionDecl *unionDecl ) final;
+                void visit( TypeInstType *typeInst ) final;
 
                 const Indexer *indexer;
@@ -182 +198 @@
         };
 
-        class CompoundLiteral : public GenPoly::DeclMutator {
+        class CompoundLiteral final : public GenPoly::DeclMutator {
                 DeclarationNode::StorageClass storageclass = DeclarationNode::NoStorageClass;
 
-                virtual DeclarationWithType * mutate( ObjectDecl *objectDecl );
-                virtual Expression *mutate( CompoundLiteralExpr *compLitExpr );
+                using GenPoly::DeclMutator::mutate;
+                DeclarationWithType * mutate( ObjectDecl *objectDecl ) final;
+                Expression *mutate( CompoundLiteralExpr *compLitExpr ) final;
         };
 
         void validate( std::list< Declaration * > &translationUnit, bool doDebug ) {
                 EnumAndPointerDecayPass epc;
-                Pass2 pass2( doDebug, 0 );
+                LinkReferenceToTypes lrt( doDebug, 0 );
                 Pass3 pass3( 0 );
                 CompoundLiteral compoundliteral;
@@ -197 +214 @@
                 EliminateTypedef::eliminateTypedef( translationUnit );
                 HoistStruct::hoistStruct( translationUnit );
+                ReturnTypeFixer::fix( translationUnit ); // must happen before autogen
                 autogenerateRoutines( translationUnit ); // moved up, used to be below compoundLiteral - currently needs EnumAndPointerDecayPass
                 acceptAll( translationUnit, epc );
-                acceptAll( translationUnit, pass2 );
+                acceptAll( translationUnit, lrt );
                 ReturnChecker::checkFunctionReturns( translationUnit );
                 compoundliteral.mutateDeclarationList( translationUnit );
@@ -208 +226 @@
         void validateType( Type *type, const Indexer *indexer ) {
                 EnumAndPointerDecayPass epc;
-                Pass2 pass2( false, indexer );
+                LinkReferenceToTypes lrt( false, indexer );
                 Pass3 pass3( indexer );
                 type->accept( epc );
-                type->accept( pass2 );
+                type->accept( lrt );
                 type->accept( pass3 );
         }
@@ -322 +340 @@
         }
 
-        Pass2::Pass2( bool doDebug, const Indexer *other_indexer ) : Indexer( doDebug ) {
+        LinkReferenceToTypes::LinkReferenceToTypes( bool doDebug, const Indexer *other_indexer ) : Indexer( doDebug ) {
                 if ( other_indexer ) {
                         indexer = other_indexer;
@@ -330 +348 @@
         }
 
-        void Pass2::visit( StructInstType *structInst ) {
+        void LinkReferenceToTypes::visit( StructInstType *structInst ) {
                 Parent::visit( structInst );
                 StructDecl *st = indexer->lookupStruct( structInst->get_name() );
@@ -344 +362 @@
         }
 
-        void Pass2::visit( UnionInstType *unionInst ) {
+        void LinkReferenceToTypes::visit( UnionInstType *unionInst ) {
                 Parent::visit( unionInst );
                 UnionDecl *un = indexer->lookupUnion( unionInst->get_name() );
@@ -357 +375 @@
         }
 
-        void Pass2::visit( TraitInstType *contextInst ) {
+        void LinkReferenceToTypes::visit( TraitInstType *contextInst ) {
                 Parent::visit( contextInst );
+                if ( contextInst->get_name() == "sized" ) {
+                        // "sized" is a special trait with no members - just flick the sized status on for the type variable
+                        if ( contextInst->get_parameters().size() != 1 ) {
+                                throw SemanticError( "incorrect number of context parameters: ", contextInst );
+                        }
+                        TypeExpr * param = safe_dynamic_cast< TypeExpr * > ( contextInst->get_parameters().front() );
+                        TypeInstType * inst = safe_dynamic_cast< TypeInstType * > ( param->get_type() );
+                        TypeDecl * decl = inst->get_baseType();
+                        decl->set_sized( true );
+                        // since "sized" is special, the next few steps don't apply
+                        return;
+                }
                 TraitDecl *ctx = indexer->lookupTrait( contextInst->get_name() );
                 if ( ! ctx ) {
@@ -384 +414 @@
         }
 
-        void Pass2::visit( StructDecl *structDecl ) {
+        void LinkReferenceToTypes::visit( StructDecl *structDecl ) {
                 // visit struct members first so that the types of self-referencing members are updated properly
                 Parent::visit( structDecl );
@@ -398 +428 @@
         }
 
-        void Pass2::visit( UnionDecl *unionDecl ) {
+        void LinkReferenceToTypes::visit( UnionDecl *unionDecl ) {
                 Parent::visit( unionDecl );
                 if ( ! unionDecl->get_members().empty() ) {
@@ -411 +441 @@
         }
 
-        void Pass2::visit( TypeInstType *typeInst ) {
+        void LinkReferenceToTypes::visit( TypeInstType *typeInst ) {
                 if ( NamedTypeDecl *namedTypeDecl = lookupType( typeInst->get_name() ) ) {
                         if ( TypeDecl *typeDecl = dynamic_cast< TypeDecl * >( namedTypeDecl ) ) {
@@ -582 +612 @@
 
                 typedeclNames[ typeDecl->get_name() ] = typeDecl;
-                return typeDecl;
+                return Mutator::mutate( typeDecl );
         }
 
@@ -652 +682 @@
         void EliminateTypedef::addImplicitTypedef( AggDecl * aggDecl ) {
                 if ( typedefNames.count( aggDecl->get_name() ) == 0 ) {
-                        Type *type;
+                        Type *type = nullptr;
                         if ( StructDecl * newDeclStructDecl = dynamic_cast< StructDecl * >( aggDecl ) ) {
                                 type = new StructInstType( Type::Qualifiers(), newDeclStructDecl->get_name() );
@@ -733 +763 @@
                 return new VariableExpr( newtempvar );
         }
+
+        void ReturnTypeFixer::fix( std::list< Declaration * > &translationUnit ) {
+                ReturnTypeFixer fixer;
+                acceptAll( translationUnit, fixer );
+        }
+
+        void ReturnTypeFixer::visit( FunctionDecl * functionDecl ) {
+                Parent::visit( functionDecl );
+                FunctionType * ftype = functionDecl->get_functionType();
+                std::list< DeclarationWithType * > & retVals = ftype->get_returnVals();
+                assertf( retVals.size() == 0 || retVals.size() == 1, "Function %s has too many return values: %d", functionDecl->get_name().c_str(), retVals.size() );
+                if ( retVals.size() == 1 ) {
+                        // ensure all function return values have a name - use the name of the function to disambiguate (this also provides a nice bit of help for debugging)
+                        // ensure other return values have a name
+                        DeclarationWithType * ret = retVals.front();
+                        if ( ret->get_name() == "" ) {
+                                ret->set_name( toString( "_retval_", CodeGen::genName( functionDecl ) ) );
+                        }
+                }
+        }
+
+        void ReturnTypeFixer::visit( FunctionType * ftype ) {
+                // xxx - need to handle named return values - this information needs to be saved somehow
+                // so that resolution has access to the names.
+                // Note that this pass needs to happen early so that other passes which look for tuple types
+                // find them in all of the right places, including function return types.
+                std::list< DeclarationWithType * > & retVals = ftype->get_returnVals();
+                if ( retVals.size() > 1 ) {
+                        // generate a single return parameter which is the tuple of all of the return values
+                        TupleType * tupleType = safe_dynamic_cast< TupleType * >( ResolvExpr::extractResultType( ftype ) );
+                        // ensure return value is not destructed by explicitly creating an empty ListInit node wherein maybeConstruct is false.
+                        ObjectDecl * newRet = new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, tupleType, new ListInit( std::list<Initializer*>(), noDesignators, false ) );
+                        deleteAll( retVals );
+                        retVals.clear();
+                        retVals.push_back( newRet );
+                }
+        }
 } // namespace SymTab