Changes in src/SymTab/Validate.cc [095b99a:09867ec]

File:

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

src/SymTab/Validate.cc

@@ -64 +64 @@
 #include "Common/UniqueName.h"         // for UniqueName
 #include "Common/utility.h"            // for operator+, cloneAll, deleteAll
+#include "CompilationState.h"          // skip some passes in new-ast build
 #include "Concurrency/Keywords.h"      // for applyKeywords
 #include "FixFunction.h"               // for FixFunction
@@ -270 +271 @@
         };
 
-        struct ArrayLength : public WithIndexer {
+        struct InitializerLength {
                 /// for array types without an explicit length, compute the length and store it so that it
                 /// is known to the rest of the phases. For example,
@@ -281 +282 @@
 
                 void previsit( ObjectDecl * objDecl );
+        };
+
+        struct ArrayLength : public WithIndexer {
+                static void computeLength( std::list< Declaration * > & translationUnit );
+
                 void previsit( ArrayType * arrayType );
         };
@@ -311 +317 @@
                         Stats::Heap::newPass("validate-A");
                         Stats::Time::BlockGuard guard("validate-A");
+                        VerifyCtorDtorAssign::verify( translationUnit );  // must happen before autogen, because autogen examines existing ctor/dtors
                         acceptAll( translationUnit, hoistDecls );
                         ReplaceTypedef::replaceTypedef( translationUnit );
@@ -336 +343 @@
                         Stats::Time::BlockGuard guard("validate-C");
                         acceptAll( translationUnit, genericParams );  // check as early as possible - can't happen before LinkReferenceToTypes_old
-                        VerifyCtorDtorAssign::verify( translationUnit );  // must happen before autogen, because autogen examines existing ctor/dtors
                         ReturnChecker::checkFunctionReturns( translationUnit );
                         InitTweak::fixReturnStatements( translationUnit ); // must happen before autogen
@@ -368 +374 @@
                                 mutateAll( translationUnit, compoundliteral );
                         });
-                        Stats::Time::TimeBlock("Resolve With Expressions", [&]() {
-                                ResolvExpr::resolveWithExprs( translationUnit ); // must happen before FixObjectType because user-code is resolved and may contain with variables
-                        });
+                        if (!useNewAST) {
+                                Stats::Time::TimeBlock("Resolve With Expressions", [&]() {
+                                        ResolvExpr::resolveWithExprs( translationUnit ); // must happen before FixObjectType because user-code is resolved and may contain with variables
+                                });
+                        }
                 }
                 {
                         Stats::Heap::newPass("validate-F");
                         Stats::Time::BlockGuard guard("validate-F");
-                        Stats::Time::TimeCall("Fix Object Type",
-                                FixObjectType::fix, translationUnit);
-                        Stats::Time::TimeCall("Array Length",
-                                ArrayLength::computeLength, translationUnit);
+                        if (!useNewAST) {
+                                Stats::Time::TimeCall("Fix Object Type",
+                                        FixObjectType::fix, translationUnit);
+                        }
+                        Stats::Time::TimeCall("Initializer Length",
+                                InitializerLength::computeLength, translationUnit);
+                        if (!useNewAST) {
+                                Stats::Time::TimeCall("Array Length",
+                                        ArrayLength::computeLength, translationUnit);
+                        }
                         Stats::Time::TimeCall("Find Special Declarations",
                                 Validate::findSpecialDecls, translationUnit);
                         Stats::Time::TimeCall("Fix Label Address",
                                 mutateAll<LabelAddressFixer>, translationUnit, labelAddrFixer);
-                        Stats::Time::TimeCall("Handle Attributes",
-                                Validate::handleAttributes, translationUnit);
+                        if (!useNewAST) {
+                                Stats::Time::TimeCall("Handle Attributes",
+                                        Validate::handleAttributes, translationUnit);
+                        }
                 }
         }
@@ -960 +976 @@
         }
 
+        static bool isNonParameterAttribute( Attribute * attr ) {
+                static const std::vector<std::string> bad_names = {
+                        "aligned", "__aligned__",
+                };
+                for ( auto name : bad_names ) {
+                        if ( name == attr->name ) {
+                                return true;
+                        }
+                }
+                return false;
+        }
+
         Type * ReplaceTypedef::postmutate( TypeInstType * typeInst ) {
                 // instances of typedef types will come here. If it is an instance
@@ -968 +996 @@
                         ret->location = typeInst->location;
                         ret->get_qualifiers() |= typeInst->get_qualifiers();
-                        // attributes are not carried over from typedef to function parameters/return values
-                        if ( ! inFunctionType ) {
-                                ret->attributes.splice( ret->attributes.end(), typeInst->attributes );
-                        } else {
-                                deleteAll( ret->attributes );
-                                ret->attributes.clear();
-                        }
+                        // GCC ignores certain attributes if they arrive by typedef, this mimics that.
+                        if ( inFunctionType ) {
+                                ret->attributes.remove_if( isNonParameterAttribute );
+                        }
+                        ret->attributes.splice( ret->attributes.end(), typeInst->attributes );
                         // place instance parameters on the typedef'd type
                         if ( ! typeInst->parameters.empty() ) {
@@ -1182 +1208 @@
                 if ( CodeGen::isCtorDtorAssign( funcDecl->get_name() ) ) { // TODO: also check /=, etc.
                         if ( params.size() == 0 ) {
-                                SemanticError( funcDecl, "Constructors, destructors, and assignment functions require at least one parameter " );
+                                SemanticError( funcDecl->location, "Constructors, destructors, and assignment functions require at least one parameter." );
                         }
                         ReferenceType * refType = dynamic_cast< ReferenceType * >( params.front()->get_type() );
                         if ( ! refType ) {
-                                SemanticError( funcDecl, "First parameter of a constructor, destructor, or assignment function must be a reference " );
+                                SemanticError( funcDecl->location, "First parameter of a constructor, destructor, or assignment function must be a reference." );
                         }
                         if ( CodeGen::isCtorDtor( funcDecl->get_name() ) && returnVals.size() != 0 ) {
-                                SemanticError( funcDecl, "Constructors and destructors cannot have explicit return values " );
+                                if(!returnVals.front()->get_type()->isVoid()) {
+                                        SemanticError( funcDecl->location, "Constructors and destructors cannot have explicit return values." );
+                                }
                         }
                 }
@@ -1313 +1341 @@
         }
 
+        void InitializerLength::computeLength( std::list< Declaration * > & translationUnit ) {
+                PassVisitor<InitializerLength> len;
+                acceptAll( translationUnit, len );
+        }
+
         void ArrayLength::computeLength( std::list< Declaration * > & translationUnit ) {
                 PassVisitor<ArrayLength> len;
@@ -1318 +1351 @@
         }
 
-        void ArrayLength::previsit( ObjectDecl * objDecl ) {
+        void InitializerLength::previsit( ObjectDecl * objDecl ) {
                 if ( ArrayType * at = dynamic_cast< ArrayType * >( objDecl->type ) ) {
                         if ( at->dimension ) return;
@@ -1372 +1405 @@
         /// Replaces enum types by int, and function/array types in function parameter and return
         /// lists by appropriate pointers
+        /*
         struct EnumAndPointerDecay_new {
                 const ast::EnumDecl * previsit( const ast::EnumDecl * enumDecl ) {
@@ -1422 +1456 @@
                 }
         };
+        */
 
         /// expand assertions from a trait instance, performing appropriate type variable substitutions
@@ -1440 +1475 @@
         }
 
+        /*
+
         /// Associates forward declarations of aggregates with their definitions
         class LinkReferenceToTypes_new final
@@ -1506 +1543 @@
                 }
 
-                void checkGenericParameters( const ast::ReferenceToType * inst ) {
+                void checkGenericParameters( const ast::BaseInstType * inst ) {
                         for ( const ast::Expr * param : inst->params ) {
                                 if ( ! dynamic_cast< const ast::TypeExpr * >( param ) ) {
@@ -1770 +1807 @@
                 static const node_t * forallFixer(
                         const CodeLocation & loc, const node_t * node,
-                        ast::ParameterizedType::ForallList parent_t::* forallField
+                        ast::FunctionType::ForallList parent_t::* forallField
                 ) {
                         for ( unsigned i = 0; i < (node->* forallField).size(); ++i ) {
@@ -1821 +1858 @@
                 }
         };
+        */
 } // anonymous namespace
 
+/*
 const ast::Type * validateType(
                 const CodeLocation & loc, const ast::Type * type, const ast::SymbolTable & symtab ) {
-        ast::Pass< EnumAndPointerDecay_new > epc;
+        // ast::Pass< EnumAndPointerDecay_new > epc;
         ast::Pass< LinkReferenceToTypes_new > lrt{ loc, symtab };
         ast::Pass< ForallPointerDecay_new > fpd{ loc };
 
-        return type->accept( epc )->accept( lrt )->accept( fpd );
+        return type->accept( lrt )->accept( fpd );
 }
+*/
 
 } // namespace SymTab