Changes in src/SymTab/Validate.cc [7c919559:4559b34]

File:

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

src/SymTab/Validate.cc

@@ -194 +194 @@
         };
 
-        // These structs are the sub-sub-passes of ForallPointerDecay_old.
-
-        struct TraitExpander_old final {
-                void previsit( FunctionType * );
-                void previsit( StructDecl * );
-                void previsit( UnionDecl * );
-        };
-
-        struct AssertionFixer_old final {
-                void previsit( FunctionType * );
-                void previsit( StructDecl * );
-                void previsit( UnionDecl * );
-        };
-
-        struct CheckOperatorTypes_old final {
-                void previsit( ObjectDecl * );
-        };
-
-        struct FixUniqueIds_old final {
-                void previsit( DeclarationWithType * );
-        };
-
         struct ReturnChecker : public WithGuards {
                 /// Checks that return statements return nothing if their return type is void
@@ -395 +373 @@
                                 TranslateDimensionGenericParameters::translateDimensions( translationUnit );
                         });
-                        if (!useNewAST) {
                         Stats::Time::TimeBlock("Resolve Enum Initializers", [&]() {
                                 acceptAll( translationUnit, rei ); // must happen after translateDimensions because rei needs identifier lookup, which needs name mangling
                         });
-                        }
                         Stats::Time::TimeBlock("Check Function Returns", [&]() {
                                 ReturnChecker::checkFunctionReturns( translationUnit );
@@ -409 +385 @@
         }
 
-        static void decayForallPointers( std::list< Declaration * > & translationUnit ) {
-                PassVisitor<TraitExpander_old> te;
-                acceptAll( translationUnit, te );
-                PassVisitor<AssertionFixer_old> af;
-                acceptAll( translationUnit, af );
-                PassVisitor<CheckOperatorTypes_old> cot;
-                acceptAll( translationUnit, cot );
-                PassVisitor<FixUniqueIds_old> fui;
-                acceptAll( translationUnit, fui );
-        }
-
         void validate_D( std::list< Declaration * > & translationUnit ) {
+                PassVisitor<ForallPointerDecay_old> fpd;
                 {
                         Stats::Heap::newPass("validate-D");
@@ -428 +394 @@
                         });
                         Stats::Time::TimeBlock("Forall Pointer Decay", [&]() {
-                                decayForallPointers( translationUnit ); // must happen before autogenerateRoutines, after Concurrency::applyKeywords because uniqueIds must be set on declaration before resolution
+                                acceptAll( translationUnit, fpd ); // must happen before autogenerateRoutines, after Concurrency::applyKeywords because uniqueIds must be set on declaration before resolution
                         });
                         Stats::Time::TimeBlock("Hoist Control Declarations", [&]() {
@@ -487 +453 @@
         }
 
+        void decayForallPointers( std::list< Declaration * > & translationUnit ) {
+                PassVisitor<ForallPointerDecay_old> fpd;
+                acceptAll( translationUnit, fpd );
+        }
+
         void validate( std::list< Declaration * > &translationUnit, __attribute__((unused)) bool doDebug ) {
                 validate_A( translationUnit );
@@ -499 +470 @@
                 PassVisitor<EnumAndPointerDecay_old> epc;
                 PassVisitor<LinkReferenceToTypes_old> lrt( indexer );
-                PassVisitor<TraitExpander_old> te;
-                PassVisitor<AssertionFixer_old> af;
-                PassVisitor<CheckOperatorTypes_old> cot;
-                PassVisitor<FixUniqueIds_old> fui;
+                PassVisitor<ForallPointerDecay_old> fpd;
                 type->accept( epc );
                 type->accept( lrt );
-                type->accept( te );
-                type->accept( af );
-                type->accept( cot );
-                type->accept( fui );
+                type->accept( fpd );
         }
 
@@ -974 +939 @@
                                         // need to resolve enumerator initializers early so that other passes that determine if an expression is constexpr have the appropriate information.
                                         SingleInit * init = strict_dynamic_cast<SingleInit *>( field->init );
-                                        ResolvExpr::findSingleExpression( init->value, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), indexer );
+                                        if ( !enumDecl->base || dynamic_cast<BasicType *>(enumDecl->base))
+                                                ResolvExpr::findSingleExpression( init->value, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), indexer );
+                                        else {
+                                                if (dynamic_cast<PointerType *>(enumDecl->base)) {
+                                                        auto typePtr = dynamic_cast<PointerType *>(enumDecl->base);
+                                                        ResolvExpr::findSingleExpression( init->value,
+                                                         new PointerType( Type::Qualifiers(), typePtr->base ), indexer );
+                                                } else {
+                                                        ResolvExpr::findSingleExpression( init->value, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), indexer );
+                                                }
+                                        }
+                                        
                                 }
                         }
+
                 } // if
         }
@@ -1007 +984 @@
         }
 
-        /// Replace all traits in assertion lists with their assertions.
-        void expandTraits( std::list< TypeDecl * > & forall ) {
-                for ( TypeDecl * type : forall ) {
-                        std::list< DeclarationWithType * > asserts;
-                        asserts.splice( asserts.end(), type->assertions );
-                        // expand trait instances into their members
-                        for ( DeclarationWithType * assertion : asserts ) {
-                                if ( TraitInstType * traitInst = dynamic_cast< TraitInstType * >( assertion->get_type() ) ) {
-                                        // expand trait instance into all of its members
-                                        expandAssertions( traitInst, back_inserter( type->assertions ) );
-                                        delete traitInst;
-                                } else {
-                                        // pass other assertions through
-                                        type->assertions.push_back( assertion );
-                                } // if
-                        } // for
-                }
-        }
-
-        /// Fix each function in the assertion list and check for invalid void type.
-        void fixAssertions(
-                        std::list< TypeDecl * > & forall, BaseSyntaxNode * node ) {
-                for ( TypeDecl * type : forall ) {
-                        for ( DeclarationWithType *& assertion : type->assertions ) {
-                                bool isVoid = fixFunction( assertion );
-                                if ( isVoid ) {
-                                        SemanticError( node, "invalid type void in assertion of function " );
-                                } // if
-                        } // for
-                }
-        }
-
         void ForallPointerDecay_old::previsit( ObjectDecl * object ) {
                 // ensure that operator names only apply to functions or function pointers
@@ -1061 +1006 @@
         void ForallPointerDecay_old::previsit( UnionDecl * aggrDecl ) {
                 forallFixer( aggrDecl->parameters, aggrDecl );
-        }
-
-        void TraitExpander_old::previsit( FunctionType * ftype ) {
-                expandTraits( ftype->forall );
-        }
-
-        void TraitExpander_old::previsit( StructDecl * aggrDecl ) {
-                expandTraits( aggrDecl->parameters );
-        }
-
-        void TraitExpander_old::previsit( UnionDecl * aggrDecl ) {
-                expandTraits( aggrDecl->parameters );
-        }
-
-        void AssertionFixer_old::previsit( FunctionType * ftype ) {
-                fixAssertions( ftype->forall, ftype );
-        }
-
-        void AssertionFixer_old::previsit( StructDecl * aggrDecl ) {
-                fixAssertions( aggrDecl->parameters, aggrDecl );
-        }
-
-        void AssertionFixer_old::previsit( UnionDecl * aggrDecl ) {
-                fixAssertions( aggrDecl->parameters, aggrDecl );
-        }
-
-        void CheckOperatorTypes_old::previsit( ObjectDecl * object ) {
-                // ensure that operator names only apply to functions or function pointers
-                if ( CodeGen::isOperator( object->name ) && ! dynamic_cast< FunctionType * >( object->type->stripDeclarator() ) ) {
-                        SemanticError( object->location, toCString( "operator ", object->name.c_str(), " is not a function or function pointer." )  );
-                }
-        }
-
-        void FixUniqueIds_old::previsit( DeclarationWithType * decl ) {
-                decl->fixUniqueId();
         }
 
@@ -1240 +1150 @@
                         declsToAddBefore.push_back( new UnionDecl( aggDecl->name, noAttributes, tyDecl->linkage ) );
                 } else if ( EnumInstType * enumDecl = dynamic_cast< EnumInstType * >( designatorType ) ) {
-                        declsToAddBefore.push_back( new EnumDecl( enumDecl->name, noAttributes, tyDecl->linkage ) );
+                        // declsToAddBefore.push_back( new EnumDecl( enumDecl->name, noAttributes, tyDecl->linkage, enumDecl->baseEnum->base ) );
+                        if (enumDecl->baseEnum) {
+                                declsToAddBefore.push_back( new EnumDecl( enumDecl->name, noAttributes, tyDecl->linkage, enumDecl->baseEnum->base ) );
+                        } else {
+                                declsToAddBefore.push_back( new EnumDecl( enumDecl->name, noAttributes, tyDecl->linkage ) );
+                        }
                 } // if
                 return tyDecl->clone();