Changes in src/SymTab/Validate.cc [98538288:4615ac8]

File:

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

src/SymTab/Validate.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 21:50:04 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Dec 13 23:43:34 2019
-// Update Count     : 363
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed Aug  7 6:42:00 2019
+// Update Count     : 360
 //
 
@@ -69 +69 @@
 #include "InitTweak/GenInit.h"         // for fixReturnStatements
 #include "InitTweak/InitTweak.h"       // for isCtorDtorAssign
+#include "Parser/LinkageSpec.h"        // for C
 #include "ResolvExpr/typeops.h"        // for typesCompatible
 #include "ResolvExpr/Resolver.h"       // for findSingleExpression
 #include "ResolvExpr/ResolveTypeof.h"  // for resolveTypeof
 #include "SymTab/Autogen.h"            // for SizeType
-#include "SynTree/LinkageSpec.h"       // for C
 #include "SynTree/Attribute.h"         // for noAttributes, Attribute
 #include "SynTree/Constant.h"          // for Constant
@@ -81 +81 @@
 #include "SynTree/Label.h"             // for operator==, Label
 #include "SynTree/Mutator.h"           // for Mutator
+#include "SynTree/TopLvalue.h"         // for assertTopLvalue, clearInnerLvalue
 #include "SynTree/Type.h"              // for Type, TypeInstType, EnumInstType
 #include "SynTree/TypeSubstitution.h"  // for TypeSubstitution
@@ -308 +309 @@
                 PassVisitor<FixQualifiedTypes> fixQual;
 
+                assertTopLvalue( translationUnit );
                 {
                         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 );
@@ -317 +318 @@
                         acceptAll( translationUnit, epc ); // must happen before VerifyCtorDtorAssign, because void return objects should not exist; before LinkReferenceToTypes_old because it is an indexer and needs correct types for mangling
                 }
+                assertTopLvalue( translationUnit );
                 {
                         Stats::Heap::newPass("validate-B");
                         Stats::Time::BlockGuard guard("validate-B");
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Link Reference To Types", [&]() {
                                 acceptAll( translationUnit, lrt ); // must happen before autogen, because sized flag needs to propagate to generated functions
                         });
+                        clearInnerLvalue( translationUnit );
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Fix Qualified Types", [&]() {
                                 mutateAll( translationUnit, fixQual ); // must happen after LinkReferenceToTypes_old, because aggregate members are accessed
                         });
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Hoist Structs", [&]() {
                                 HoistStruct::hoistStruct( translationUnit ); // must happen after EliminateTypedef, so that aggregate typedefs occur in the correct order
                         });
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Eliminate Typedefs", [&]() {
                                 EliminateTypedef::eliminateTypedef( translationUnit ); //
                         });
                 }
+                assertTopLvalue( translationUnit );
                 {
                         Stats::Heap::newPass("validate-C");
                         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
                 }
+                assertTopLvalue( translationUnit );
                 {
                         Stats::Heap::newPass("validate-D");
                         Stats::Time::BlockGuard guard("validate-D");
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Apply Concurrent Keywords", [&]() {
                                 Concurrency::applyKeywords( translationUnit );
                         });
+                        clearInnerLvalue( translationUnit );
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Forall Pointer Decay", [&]() {
                                 acceptAll( translationUnit, fpd ); // must happen before autogenerateRoutines, after Concurrency::applyKeywords because uniqueIds must be set on declaration before resolution
                         });
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Hoist Control Declarations", [&]() {
                                 ControlStruct::hoistControlDecls( translationUnit );  // hoist initialization out of for statements; must happen before autogenerateRoutines
                         });
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Generate Autogen routines", [&]() {
                                 autogenerateRoutines( translationUnit ); // moved up, used to be below compoundLiteral - currently needs EnumAndPointerDecay_old
                         });
-                }
+                        clearInnerLvalue( translationUnit );
+                }
+                assertTopLvalue( translationUnit );
                 {
                         Stats::Heap::newPass("validate-E");
                         Stats::Time::BlockGuard guard("validate-E");
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Implement Mutex Func", [&]() {
                                 Concurrency::implementMutexFuncs( translationUnit );
                         });
+                        clearInnerLvalue( translationUnit );
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Implement Thread Start", [&]() {
                                 Concurrency::implementThreadStarter( translationUnit );
                         });
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Compound Literal", [&]() {
                                 mutateAll( translationUnit, compoundliteral );
                         });
+                        assertTopLvalue( translationUnit );
                         Stats::Time::TimeBlock("Resolve With Expressions", [&]() {
                                 ResolvExpr::resolveWithExprs( translationUnit ); // must happen before FixObjectType because user-code is resolved and may contain with variables
                         });
-                }
+                        clearInnerLvalue( translationUnit );
+                }
+                assertTopLvalue( translationUnit );
                 {
                         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);
-                        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);
-                }
+                        assertTopLvalue( translationUnit );
+                        Stats::Time::TimeBlock("Fix Object Type", [&]() {
+                                FixObjectType::fix( translationUnit );
+                        });
+                        assertTopLvalue( translationUnit );
+                        Stats::Time::TimeBlock("Array Length", [&]() {
+                                ArrayLength::computeLength( translationUnit );
+                        });
+                        clearInnerLvalue( translationUnit );
+                        assertTopLvalue( translationUnit );
+                        Stats::Time::TimeBlock("Find Special Declarations", [&]() {
+                                Validate::findSpecialDecls( translationUnit );
+                        });
+                        assertTopLvalue( translationUnit );
+                        Stats::Time::TimeBlock("Fix Label Address", [&]() {
+                                mutateAll( translationUnit, labelAddrFixer );
+                        });
+                        assertTopLvalue( translationUnit );
+                        Stats::Time::TimeBlock("Handle Attributes", [&]() {
+                                Validate::handleAttributes( translationUnit );
+                        });
+                }
+                assertTopLvalue( translationUnit );
         }
 
@@ -1044 +1080 @@
                 Type * designatorType = tyDecl->base->stripDeclarator();
                 if ( StructInstType * aggDecl = dynamic_cast< StructInstType * >( designatorType ) ) {
-                        declsToAddBefore.push_back( new StructDecl( aggDecl->name, AggregateDecl::Struct, noAttributes, tyDecl->linkage ) );
+                        declsToAddBefore.push_back( new StructDecl( aggDecl->name, DeclarationNode::Struct, noAttributes, tyDecl->linkage ) );
                 } else if ( UnionInstType * aggDecl = dynamic_cast< UnionInstType * >( designatorType ) ) {
                         declsToAddBefore.push_back( new UnionDecl( aggDecl->name, noAttributes, tyDecl->linkage ) );
@@ -1182 +1218 @@
                 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 " );
                         }
                 }
@@ -1300 +1334 @@
         void FixObjectType::previsit( ObjectDecl * objDecl ) {
                 Type * new_type = ResolvExpr::resolveTypeof( objDecl->get_type(), indexer );
+                new_type->get_qualifiers() -= Type::Lvalue; // even if typeof is lvalue, variable can never have lvalue-qualified type
                 objDecl->set_type( new_type );
         }
@@ -1305 +1340 @@
         void FixObjectType::previsit( FunctionDecl * funcDecl ) {
                 Type * new_type = ResolvExpr::resolveTypeof( funcDecl->type, indexer );
+                new_type->get_qualifiers() -= Type::Lvalue; // even if typeof is lvalue, variable can never have lvalue-qualified type
                 funcDecl->set_type( new_type );
         }
@@ -1311 +1347 @@
                 if ( typeDecl->get_base() ) {
                         Type * new_type = ResolvExpr::resolveTypeof( typeDecl->get_base(), indexer );
+                        new_type->get_qualifiers() -= Type::Lvalue; // even if typeof is lvalue, variable can never have lvalue-qualified type
                         typeDecl->set_base( new_type );
                 } // if