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

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
@@ -271 +270 @@
         };
 
-        struct InitializerLength {
+        struct ArrayLength : public WithIndexer {
                 /// 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,
@@ -282 +281 @@
 
                 void previsit( ObjectDecl * objDecl );
-        };
-
-        struct ArrayLength : public WithIndexer {
-                static void computeLength( std::list< Declaration * > & translationUnit );
-
                 void previsit( ArrayType * arrayType );
         };
@@ -317 +311 @@
                         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 );
@@ -343 +336 @@
                         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
@@ -374 +368 @@
                                 mutateAll( translationUnit, compoundliteral );
                         });
-                        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::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");
-                        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("Fix Object Type",
+                                FixObjectType::fix, translationUnit);
+                        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);
-                        if (!useNewAST) {
-                                Stats::Time::TimeCall("Handle Attributes",
-                                        Validate::handleAttributes, translationUnit);
-                        }
+                        Stats::Time::TimeCall("Handle Attributes",
+                                Validate::handleAttributes, translationUnit);
                 }
         }
@@ -976 +960 @@
         }
 
-        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
@@ -996 +968 @@
                         ret->location = typeInst->location;
                         ret->get_qualifiers() |= typeInst->get_qualifiers();
-                        // 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 );
+                        // 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();
+                        }
                         // place instance parameters on the typedef'd type
                         if ( ! typeInst->parameters.empty() ) {
@@ -1208 +1182 @@
                 if ( CodeGen::isCtorDtorAssign( funcDecl->get_name() ) ) { // TODO: also check /=, etc.
                         if ( params.size() == 0 ) {
-                                SemanticError( funcDecl->location, "Constructors, destructors, and assignment functions require at least one parameter." );
+                                SemanticError( funcDecl, "Constructors, destructors, and assignment functions require at least one parameter " );
                         }
                         ReferenceType * refType = dynamic_cast< ReferenceType * >( params.front()->get_type() );
                         if ( ! refType ) {
-                                SemanticError( funcDecl->location, "First parameter of a constructor, destructor, or assignment function must be a reference." );
+                                SemanticError( funcDecl, "First parameter of a constructor, destructor, or assignment function must be a reference " );
                         }
                         if ( CodeGen::isCtorDtor( funcDecl->get_name() ) && returnVals.size() != 0 ) {
-                                if(!returnVals.front()->get_type()->isVoid()) {
-                                        SemanticError( funcDecl->location, "Constructors and destructors cannot have explicit return values." );
-                                }
+                                SemanticError( funcDecl, "Constructors and destructors cannot have explicit return values " );
                         }
                 }
@@ -1341 +1313 @@
         }
 
-        void InitializerLength::computeLength( std::list< Declaration * > & translationUnit ) {
-                PassVisitor<InitializerLength> len;
-                acceptAll( translationUnit, len );
-        }
-
         void ArrayLength::computeLength( std::list< Declaration * > & translationUnit ) {
                 PassVisitor<ArrayLength> len;
@@ -1351 +1318 @@
         }
 
-        void InitializerLength::previsit( ObjectDecl * objDecl ) {
+        void ArrayLength::previsit( ObjectDecl * objDecl ) {
                 if ( ArrayType * at = dynamic_cast< ArrayType * >( objDecl->type ) ) {
                         if ( at->dimension ) return;
@@ -1405 +1372 @@
         /// 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 ) {
@@ -1456 +1422 @@
                 }
         };
-        */
 
         /// expand assertions from a trait instance, performing appropriate type variable substitutions
@@ -1475 +1440 @@
         }
 
-        /*
-
         /// Associates forward declarations of aggregates with their definitions
         class LinkReferenceToTypes_new final
@@ -1543 +1506 @@
                 }
 
-                void checkGenericParameters( const ast::BaseInstType * inst ) {
+                void checkGenericParameters( const ast::ReferenceToType * inst ) {
                         for ( const ast::Expr * param : inst->params ) {
                                 if ( ! dynamic_cast< const ast::TypeExpr * >( param ) ) {
@@ -1807 +1770 @@
                 static const node_t * forallFixer(
                         const CodeLocation & loc, const node_t * node,
-                        ast::FunctionType::ForallList parent_t::* forallField
+                        ast::ParameterizedType::ForallList parent_t::* forallField
                 ) {
                         for ( unsigned i = 0; i < (node->* forallField).size(); ++i ) {
@@ -1858 +1821 @@
                 }
         };
-        */
 } // 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( lrt )->accept( fpd );
+        return type->accept( epc )->accept( lrt )->accept( fpd );
 }
-*/
 
 } // namespace SymTab