Changeset e5d9274 for src

Timestamp:

Jun 2, 2022, 3:11:21 PM (3 years ago)

Author:

caparsons <caparson@…>

Branches:

ADT, ast-experimental, master, pthread-emulation, qualifiedEnum

Children:

ced5e2a

Parents:

015925a (diff), fc134a48 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:

src

Files:

• AST/Eval.hpp (deleted)
• AST/Expr.cpp (modified) (5 diffs)
• AST/Expr.hpp (modified) (1 diff)
• AST/module.mk (modified) (1 diff)
• CodeGen/CodeGenerator.cc (modified) (1 diff)
• CodeGen/FixMain.cc (modified) (1 diff)
• CodeGen/FixMain2.cc (added)
• CodeGen/GenType.cc (modified) (4 diffs)
• CodeGen/LinkOnce.cc (modified) (1 diff)
• CodeGen/module.mk (modified) (1 diff)
• CodeTools/ResolvProtoDump.cc (modified) (1 diff)
• Common/Indenter.cc (added)
• Common/Indenter.h (modified) (2 diffs)
• Common/ResolvProtoDump.cpp (modified) (1 diff)
• Common/module.mk (modified) (1 diff)
• Concurrency/module.mk (modified) (1 diff)
• ControlStruct/ExceptDecl.cc (modified) (6 diffs)
• ControlStruct/module.mk (modified) (2 diffs)
• GenPoly/Lvalue.cc (modified) (2 diffs)
• GenPoly/Lvalue2.cc (added)
• GenPoly/module.mk (modified) (1 diff)
• InitTweak/FixInitNew.cpp (modified) (4 diffs)
• InitTweak/GenInit.cc (modified) (2 diffs)
• InitTweak/module.mk (modified) (2 diffs)
• Parser/parser.yy (modified) (14 diffs)
• ResolvExpr/AlternativeFinder.cc (modified) (1 diff)
• ResolvExpr/CandidateFinder.cpp (modified) (2 diffs)
• ResolvExpr/CommonType.cc (modified) (13 diffs)
• ResolvExpr/ConversionCost.cc (modified) (4 diffs)
• ResolvExpr/ConversionCost.h (modified) (2 diffs)
• SymTab/Autogen.h (modified) (14 diffs)
• SymTab/Demangle.cc (modified) (1 diff)
• SymTab/Demangle.h (added)
• SymTab/Mangler.h (modified) (1 diff)
• SymTab/Validate.cc (modified) (12 diffs)
• SymTab/Validate.h (modified) (3 diffs)
• SymTab/ValidateType.cc (added)
• SymTab/ValidateType.h (added)
• SymTab/demangler.cc (modified) (1 diff)
• SymTab/module.mk (modified) (1 diff)
• SynTree/BaseSyntaxNode.cc (added)
• SynTree/module.mk (modified) (1 diff)
• Tuples/TupleExpansion.cc (modified) (2 diffs)
• Tuples/Tuples.cc (modified) (5 diffs)
• Tuples/module.mk (modified) (2 diffs)
• Validate/Autogen.cpp (modified) (1 diff)
• Validate/module.mk (modified) (3 diffs)
• Virtual/module.mk (modified) (1 diff)
• main.cc (modified) (1 diff)

src/AST/Expr.cpp

@@ -10 +10 @@
 // Created On       : Wed May 15 17:00:00 2019
 // Last Modified By : Andrew Beach
-// Created On       : Tue Nov 30 14:23:00 2021
-// Update Count     : 7
+// Created On       : Wed May 18 13:56:00 2022
+// Update Count     : 8
 //
 
@@ -21 +21 @@
 
 #include "Copy.hpp"                // for shallowCopy
-#include "Eval.hpp"                // for call
 #include "GenericSubstitution.hpp"
 #include "LinkageSpec.hpp"
@@ -67 +66 @@
 // --- UntypedExpr
 
+bool UntypedExpr::get_lvalue() const {
+        std::string fname = InitTweak::getFunctionName( this );
+        return lvalueFunctionNames.count( fname );
+}
+
 UntypedExpr * UntypedExpr::createDeref( const CodeLocation & loc, const Expr * arg ) {
         assert( arg );
 
-        UntypedExpr * ret = call( loc, "*?", arg );
+        UntypedExpr * ret = createCall( loc, "*?", { arg } );
         if ( const Type * ty = arg->result ) {
                 const Type * base = InitTweak::getPointerBase( ty );
@@ -87 +91 @@
 }
 
-bool UntypedExpr::get_lvalue() const {
-        std::string fname = InitTweak::getFunctionName( this );
-        return lvalueFunctionNames.count( fname );
-}
-
 UntypedExpr * UntypedExpr::createAssign( const CodeLocation & loc, const Expr * lhs, const Expr * rhs ) {
         assert( lhs && rhs );
 
-        UntypedExpr * ret = call( loc, "?=?", lhs, rhs );
+        UntypedExpr * ret = createCall( loc, "?=?", { lhs, rhs } );
         if ( lhs->result && rhs->result ) {
                 // if both expressions are typed, assumes that this assignment is a C bitwise assignment,
@@ -102 +101 @@
         }
         return ret;
+}
+
+UntypedExpr * UntypedExpr::createCall( const CodeLocation & loc,
+                const std::string & name, std::vector<ptr<Expr>> && args ) {
+        return new UntypedExpr( loc,
+                        new NameExpr( loc, name ), std::move( args ) );
 }
 

src/AST/Expr.hpp

@@ -230 +230 @@
         /// Creates a new assignment expression
         static UntypedExpr * createAssign( const CodeLocation & loc, const Expr * lhs, const Expr * rhs );
+        /// Creates a new call of a variable.
+        static UntypedExpr * createCall( const CodeLocation & loc,
+                const std::string & name, std::vector<ptr<Expr>> && args );
 
         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }

src/AST/module.mk

@@ -29 +29 @@
         AST/DeclReplacer.cpp \
         AST/DeclReplacer.hpp \
-        AST/Eval.hpp \
         AST/Expr.cpp \
         AST/Expr.hpp \

src/CodeGen/CodeGenerator.cc

@@ -1238 +1238 @@
 } // namespace CodeGen
 
-
-unsigned Indenter::tabsize = 2;
-
-std::ostream & operator<<( std::ostream & out, const BaseSyntaxNode * node ) {
-        if ( node ) {
-                node->print( out );
-        } else {
-                out << "nullptr";
-        }
-        return out;
-}
-
 // Local Variables: //
 // tab-width: 4 //

src/CodeGen/FixMain.cc

@@ -49 +49 @@
 
 }
-
-        bool FixMain::replace_main = false;
 
         template<typename container>

src/CodeGen/GenType.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
-// Last Modified On : Wed May  1 15:24:00 2019
-// Update Count     : 23
+// Last Modified On : Fri May 20 11:18:00 2022
+// Update Count     : 24
 //
 #include "GenType.h"
@@ -50 +50 @@
                 void postvisit( TraitInstType * inst );
                 void postvisit( TypeofType * typeof );
+                void postvisit( VTableType * vtable );
                 void postvisit( QualifiedType * qualType );
 
@@ -259 +260 @@
                         if ( options.genC ) {
                                 typeString = "enum " + typeString;
-                        } 
-                } 
+                        }
+                }
                 handleQualifiers( enumInst );
         }
 
         void GenType::postvisit( TypeInstType * typeInst ) {
+                assertf( ! options.genC, "Type instance types should not reach code generation." );
                 typeString = typeInst->name + " " + typeString;
                 handleQualifiers( typeInst );
@@ -320 +322 @@
         }
 
+        void GenType::postvisit( VTableType * vtable ) {
+                assertf( ! options.genC, "Virtual table types should not reach code generation." );
+                std::ostringstream os;
+                os << "vtable(" << genType( vtable->base, "", options ) << ") " << typeString;
+                typeString = os.str();
+                handleQualifiers( vtable );
+        }
+
         void GenType::postvisit( QualifiedType * qualType ) {
                 assertf( ! options.genC, "Qualified types should not reach code generation." );

src/CodeGen/LinkOnce.cc

@@ -53 +53 @@
                                 new ConstantExpr( Constant::from_string( section_name ) )
                         );
+
+                        // Unconditionnaly add "visibility(default)" to anything with gnu.linkonce
+                        // visibility is a mess otherwise
+                        attributes.push_back(new Attribute("visibility", {new ConstantExpr( Constant::from_string( "default" ) )}));
+
                 }
                 visit_children = false;

src/CodeGen/module.mk

@@ -10 +10 @@
 ## Author           : Richard C. Bilson
 ## Created On       : Mon Jun  1 17:49:17 2015
-## Last Modified By : Peter A. Buhr
-## Last Modified On : Sat Dec 14 07:29:42 2019
-## Update Count     : 4
+## Last Modified By : Andrew Beach
+## Last Modified On : Tue May 17 14:26:00 2022
+## Update Count     : 5
 ###############################################################################
 
-#SRC +=  ArgTweak/Rewriter.cc \
-#       ArgTweak/Mutate.cc
+SRC_CODEGEN = \
+        CodeGen/FixMain2.cc \
+        CodeGen/FixMain.h \
+        CodeGen/OperatorTable.cc \
+        CodeGen/OperatorTable.h
 
-SRC_CODEGEN = \
+SRC += $(SRC_CODEGEN) \
         CodeGen/CodeGenerator.cc \
         CodeGen/CodeGenerator.h \
+        CodeGen/Generate.cc \
+        CodeGen/Generate.h \
         CodeGen/FixMain.cc \
-        CodeGen/FixMain.h \
+        CodeGen/FixNames.cc \
+        CodeGen/FixNames.h \
         CodeGen/GenType.cc \
         CodeGen/GenType.h \
         CodeGen/LinkOnce.cc \
         CodeGen/LinkOnce.h \
-        CodeGen/OperatorTable.cc \
-        CodeGen/OperatorTable.h \
         CodeGen/Options.h
 
-SRC += $(SRC_CODEGEN) CodeGen/Generate.cc CodeGen/Generate.h CodeGen/FixNames.cc CodeGen/FixNames.h
 SRCDEMANGLE += $(SRC_CODEGEN)

src/CodeTools/ResolvProtoDump.cc

@@ -304 +304 @@
 
                         // replace enums with int
-                        void previsit( EnumInstType* ) { ss << (int)BasicType::SignedInt; }
+                        void previsit( EnumInstType* ) { 
+                                // TODO: add the meaningful representation of typed int
+                                ss << (int)BasicType::SignedInt; 
+                        }
 
                         void previsit( TypeInstType* vt ) {

src/Common/Indenter.h

@@ -10 +10 @@
 // Created On       : Fri Jun 30 16:55:23 2017
 // Last Modified By : Andrew Beach
-// Last Modified On : Fri Aug 11 11:15:00 2017
-// Update Count     : 1
+// Last Modified On : Fri May 13 14:10:00 2022
+// Update Count     : 2
 //
 
-#ifndef INDENTER_H
-#define INDENTER_H
+#pragma once
+
+#include <ostream>
 
 struct Indenter {
@@ -37 +38 @@
         return out << std::string(indent.indent * indent.amt, ' ');
 }
-
-#endif // INDENTER_H

src/Common/ResolvProtoDump.cpp

@@ -227 +227 @@
         }
 
-        void previsit( const ast::EnumInstType * ) {
+        void previsit( const ast::EnumInstType * enumInst) {
+                // TODO: Add the meaningful text representation of typed enum
                 ss << (int)ast::BasicType::SignedInt;
         }

src/Common/module.mk

@@ -10 +10 @@
 ## Author           : Richard C. Bilson
 ## Created On       : Mon Jun  1 17:49:17 2015
-## Last Modified By : Peter A. Buhr
-## Last Modified On : Tue Sep 27 11:06:38 2016
-## Update Count     : 4
+## Last Modified By : Andrew Beach
+## Last Modified On : Tue May 17 14:27:00 2022
+## Update Count     : 5
 ###############################################################################
 
 SRC_COMMON = \
-      Common/Assert.cc \
-      Common/CodeLocation.h \
-      Common/CodeLocationTools.hpp \
-      Common/CodeLocationTools.cpp \
-      Common/CompilerError.h \
-      Common/Debug.h \
-      Common/DeclStats.hpp \
-      Common/DeclStats.cpp \
-      Common/ErrorObjects.h \
-      Common/Eval.cc \
-      Common/Examine.cc \
-      Common/Examine.h \
-      Common/FilterCombos.h \
-      Common/Indenter.h \
-      Common/PassVisitor.cc \
-      Common/PassVisitor.h \
-      Common/PassVisitor.impl.h \
-      Common/PassVisitor.proto.h \
-      Common/PersistentMap.h \
-      Common/ResolvProtoDump.hpp \
-      Common/ResolvProtoDump.cpp \
-      Common/ScopedMap.h \
-      Common/SemanticError.cc \
-      Common/SemanticError.h \
-      Common/Stats.h \
-      Common/Stats/Base.h \
-      Common/Stats/Counter.cc \
-      Common/Stats/Counter.h \
-      Common/Stats/Heap.cc \
-      Common/Stats/Heap.h \
-      Common/Stats/ResolveTime.cc \
-      Common/Stats/ResolveTime.h \
-      Common/Stats/Stats.cc \
-      Common/Stats/Time.cc \
-      Common/Stats/Time.h \
-      Common/UnimplementedError.h \
-      Common/UniqueName.cc \
-      Common/UniqueName.h \
-      Common/utility.h \
-      Common/VectorMap.h
+        Common/Assert.cc \
+        Common/CodeLocation.h \
+        Common/CodeLocationTools.hpp \
+        Common/CodeLocationTools.cpp \
+        Common/CompilerError.h \
+        Common/Debug.h \
+        Common/DeclStats.hpp \
+        Common/DeclStats.cpp \
+        Common/ErrorObjects.h \
+        Common/Eval.cc \
+        Common/Examine.cc \
+        Common/Examine.h \
+        Common/FilterCombos.h \
+        Common/Indenter.h \
+        Common/Indenter.cc \
+        Common/PassVisitor.cc \
+        Common/PassVisitor.h \
+        Common/PassVisitor.impl.h \
+        Common/PassVisitor.proto.h \
+        Common/PersistentMap.h \
+        Common/ResolvProtoDump.hpp \
+        Common/ResolvProtoDump.cpp \
+        Common/ScopedMap.h \
+        Common/SemanticError.cc \
+        Common/SemanticError.h \
+        Common/Stats.h \
+        Common/Stats/Base.h \
+        Common/Stats/Counter.cc \
+        Common/Stats/Counter.h \
+        Common/Stats/Heap.cc \
+        Common/Stats/Heap.h \
+        Common/Stats/ResolveTime.cc \
+        Common/Stats/ResolveTime.h \
+        Common/Stats/Stats.cc \
+        Common/Stats/Time.cc \
+        Common/Stats/Time.h \
+        Common/UnimplementedError.h \
+        Common/UniqueName.cc \
+        Common/UniqueName.h \
+        Common/utility.h \
+        Common/VectorMap.h
 
-SRC += $(SRC_COMMON) Common/DebugMalloc.cc
+SRC += $(SRC_COMMON) \
+        Common/DebugMalloc.cc
+
 SRCDEMANGLE += $(SRC_COMMON)

src/Concurrency/module.mk

@@ -10 +10 @@
 ## Author           : Thierry Delisle
 ## Created On       : Mon Mar 13 12:48:40 2017
-## Last Modified By :
-## Last Modified On :
-## Update Count     : 0
+## Last Modified By : Andrew Beach
+## Last Modified On : Tue May 17 13:28:00 2022
+## Update Count     : 1
 ###############################################################################
 
-SRC_CONCURRENCY = \
+SRC += \
         Concurrency/KeywordsNew.cpp \
-        Concurrency/Keywords.cc
-
-SRC += $(SRC_CONCURRENCY) \
+        Concurrency/Keywords.cc \
         Concurrency/Keywords.h \
         Concurrency/Waitfor.cc \
         Concurrency/Waitfor.h
-
-SRCDEMANGLE += $(SRC_CONCURRENCY)
-

src/ControlStruct/ExceptDecl.cc

@@ -9 +9 @@
 // Author           : Henry Xue
 // Created On       : Tue Jul 20 04:10:50 2021
-// Last Modified By : Henry Xue
-// Last Modified On : Tue Aug 03 10:42:26 2021
-// Update Count     : 4
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed May 25 16:43:00 2022
+// Update Count     : 5
 //
 
@@ -39 +39 @@
 }
 
-TypeInstType * makeExceptInstType(
-        const std::string & exceptionName,
-        const std::list< Expression *> & parameters
-) {
-        TypeInstType * exceptInstType = new TypeInstType(
+StructInstType * makeExceptInstType(
+        const std::string & exceptionName,
+        const std::list< Expression *> & parameters
+) {
+        StructInstType * exceptInstType = new StructInstType(
                 noQualifiers,
-                exceptionName,
-                false
+                exceptionName
         );
         cloneAll( parameters, exceptInstType->parameters );
@@ -151 +150 @@
                 nullptr,
                 new PointerType( noQualifiers,
-                        new TypeInstType( Type::Const, "__cfavir_type_info", false ) ),
+                        new StructInstType( Type::Const, "__cfavir_type_info" ) ),
                 nullptr
         ) );
@@ -257 +256 @@
         const std::string & exceptionName,
         const std::list< TypeDecl *> & forallClause,
-        const std::list< Expression *> & parameters, 
+        const std::list< Expression *> & parameters,
         const std::list< Declaration *> & members
 ) {
@@ -302 +301 @@
 ObjectDecl * ehmExternVtable(
         const std::string & exceptionName,
-        const std::list< Expression *> & parameters, 
+        const std::list< Expression *> & parameters,
         const std::string & tableName
 ) {
@@ -457 +456 @@
 }
 
+class VTableCore : public WithDeclsToAdd {
+public:
+        // Remove any remaining vtable type nodes in the tree.
+        Type * postmutate( VTableType * vtableType );
+};
+
+Type * VTableCore::postmutate( VTableType * vtableType ) {
+        auto inst = strict_dynamic_cast<ReferenceToType *>( vtableType->base );
+
+        std::string vtableName = Virtual::vtableTypeName( inst->name );
+        StructInstType * newType = new StructInstType( noQualifiers, vtableName );
+        cloneAll( inst->parameters, newType->parameters );
+
+        delete vtableType;
+        return newType;
+}
+
 void translateExcept( std::list< Declaration *> & translationUnit ) {
         PassVisitor<ExceptDeclCore> translator;
         mutateAll( translationUnit, translator );
-}
-
-}
+        PassVisitor<VTableCore> typeTranslator;
+        mutateAll( translationUnit, typeTranslator );
+}
+
+}

src/ControlStruct/module.mk

@@ -10 +10 @@
 ## Author           : Richard C. Bilson
 ## Created On       : Mon Jun  1 17:49:17 2015
-## Last Modified By : Peter A. Buhr
-## Last Modified On : Sat Jan 29 12:04:19 2022
-## Update Count     : 7
+## Last Modified By : Andrew Beach
+## Last Modified On : Tue May 17 14:30:00 2022
+## Update Count     : 8
 ###############################################################################
 
-SRC_CONTROLSTRUCT = \
+SRC += \
         ControlStruct/ExceptDecl.cc \
         ControlStruct/ExceptDecl.h \
+        ControlStruct/ExceptTranslateNew.cpp \
+        ControlStruct/ExceptTranslate.cc \
+        ControlStruct/ExceptTranslate.h \
         ControlStruct/FixLabels.cpp \
         ControlStruct/FixLabels.hpp \
@@ -37 +40 @@
         ControlStruct/Mutate.h
 
-SRC += $(SRC_CONTROLSTRUCT) \
-        ControlStruct/ExceptTranslateNew.cpp \
-        ControlStruct/ExceptTranslate.cc \
-        ControlStruct/ExceptTranslate.h
-
-SRCDEMANGLE += $(SRC_CONTROLSTRUCT)
-

src/GenPoly/Lvalue.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Dec 13 23:14:38 2019
-// Update Count     : 7
+// Last Modified By : Andrew Beach
+// Last Modified On : Mon May 16 14:09:00 2022
+// Update Count     : 8
 //
 
@@ -125 +125 @@
         } // namespace
 
-        static bool referencesEliminated = false;
-        // used by UntypedExpr::createDeref to determine whether result type of dereference should be ReferenceType or value type.
-        bool referencesPermissable() {
-                return ! referencesEliminated;
-        }
+        // Stored elsewhere (Lvalue2, initially false).
+        extern bool referencesEliminated;
 
         void convertLvalue( std::list< Declaration* > & translationUnit ) {

src/GenPoly/module.mk

@@ -10 +10 @@
 ## Author           : Richard C. Bilson
 ## Created On       : Mon Jun  1 17:49:17 2015
-## Last Modified By : Peter A. Buhr
-## Last Modified On : Mon Jun  1 17:52:30 2015
-## Update Count     : 1
+## Last Modified By : Andrew Beach
+## Last Modified On : Tue May 17 14:31:00 2022
+## Update Count     : 2
 ###############################################################################
 
-SRC += GenPoly/Box.cc \
-       GenPoly/Box.h \
-       GenPoly/ErasableScopedMap.h \
-       GenPoly/FindFunction.cc \
-       GenPoly/FindFunction.h \
-       GenPoly/GenPoly.cc \
-       GenPoly/GenPoly.h \
-       GenPoly/InstantiateGeneric.cc \
-       GenPoly/InstantiateGeneric.h \
-       GenPoly/Lvalue.cc \
-       GenPoly/Lvalue.h \
-       GenPoly/ScopedSet.h \
-       GenPoly/ScrubTyVars.cc \
-       GenPoly/ScrubTyVars.h \
-       GenPoly/Specialize.cc \
-       GenPoly/Specialize.h
+SRC_GENPOLY = \
+        GenPoly/GenPoly.cc \
+        GenPoly/GenPoly.h \
+        GenPoly/Lvalue2.cc \
+        GenPoly/Lvalue.h
 
-SRCDEMANGLE += GenPoly/GenPoly.cc GenPoly/GenPoly.h GenPoly/Lvalue.cc GenPoly/Lvalue.h
+SRC += $(SRC_GENPOLY) \
+        GenPoly/Box.cc \
+        GenPoly/Box.h \
+        GenPoly/ErasableScopedMap.h \
+        GenPoly/FindFunction.cc \
+        GenPoly/FindFunction.h \
+        GenPoly/InstantiateGeneric.cc \
+        GenPoly/InstantiateGeneric.h \
+        GenPoly/Lvalue.cc \
+        GenPoly/ScopedSet.h \
+        GenPoly/ScrubTyVars.cc \
+        GenPoly/ScrubTyVars.h \
+        GenPoly/Specialize.cc \
+        GenPoly/Specialize.h
 
+SRCDEMANGLE += $(SRC_GENPOLY)

src/InitTweak/FixInitNew.cpp

@@ -454 +454 @@
 
                 auto expr = new ast::ImplicitCopyCtorExpr( appExpr->location, mutExpr );
-                // Move the type substitution to the new top-level, if it is attached to the appExpr.
-                // Ensure it is not deleted with the ImplicitCopyCtorExpr by removing it before deletion.
-                // The substitution is needed to obtain the type of temporary variables so that copy constructor
-                // calls can be resolved.
+                // Move the type substitution to the new top-level. The substitution
+                // is needed to obtain the type of temporary variables so that copy
+                // constructor calls can be resolved.
                 assert( typeSubs );
-                // assert (mutExpr->env);
                 expr->env = tmp;
-                // mutExpr->env = nullptr;
-                //std::swap( expr->env, appExpr->env );
                 return expr;
         }
 
         void ResolveCopyCtors::previsit(const ast::Expr * expr) {
-                if (expr->env) {
-                        GuardValue(env);
-                        GuardValue(envModified);
-                        env = expr->env->clone();
-                        envModified = false;
-                }
+                if ( nullptr == expr->env ) {
+                        return;
+                }
+                GuardValue( env ) = expr->env->clone();
+                GuardValue( envModified ) = false;
         }
 
         const ast::Expr * ResolveCopyCtors::postvisit(const ast::Expr * expr) {
-                if (expr->env) {
-                        if (envModified) {
-                                auto mutExpr = mutate(expr);
-                                mutExpr->env = env;
-                                return mutExpr;
-                        }
-                        else {
-                                // env was not mutated, skip and delete the shallow copy
-                                delete env;
-                                return expr;
-                        }
-                }
-                else {
+                // No local environment, skip.
+                if ( nullptr == expr->env ) {
+                        return expr;
+                // Environment was modified, mutate and replace.
+                } else if ( envModified ) {
+                        auto mutExpr = mutate(expr);
+                        mutExpr->env = env;
+                        return mutExpr;
+                // Environment was not mutated, delete the shallow copy before guard.
+                } else {
+                        delete env;
                         return expr;
                 }
@@ -497 +490 @@
         const ast::Expr * ResolveCopyCtors::makeCtorDtor( const std::string & fname, const ast::ObjectDecl * var, const ast::Expr * cpArg ) {
                 assert( var );
-                assert (var->isManaged());
-                assert (!cpArg || cpArg->isManaged());
+                assert( var->isManaged() );
+                assert( !cpArg || cpArg->isManaged() );
                 // arrays are not copy constructed, so this should always be an ExprStmt
                 ast::ptr< ast::Stmt > stmt = genCtorDtor(var->location, fname, var, cpArg );
@@ -504 +497 @@
                 auto exprStmt = stmt.strict_as<ast::ImplicitCtorDtorStmt>()->callStmt.strict_as<ast::ExprStmt>();
                 ast::ptr<ast::Expr> untyped = exprStmt->expr; // take ownership of expr
-                // exprStmt->expr = nullptr;
 
                 // resolve copy constructor
@@ -516 +508 @@
                         env->add( *resolved->env );
                         envModified = true;
-                        // delete resolved->env;
                         auto mut = mutate(resolved.get());
                         assertf(mut == resolved.get(), "newly resolved expression must be unique");
                         mut->env = nullptr;
                 } // if
-                // delete stmt;
                 if ( auto assign = resolved.as<ast::TupleAssignExpr>() ) {
                         // fix newly generated StmtExpr

src/InitTweak/GenInit.cc

@@ -368 +368 @@
 
         struct ReturnFixer_New final :
-                        public ast::WithStmtsToAdd<>, ast::WithGuards {
+                        public ast::WithStmtsToAdd<>, ast::WithGuards, ast::WithShortCircuiting {
                 void previsit( const ast::FunctionDecl * decl );
                 const ast::ReturnStmt * previsit( const ast::ReturnStmt * stmt );
@@ -376 +376 @@
 
         void ReturnFixer_New::previsit( const ast::FunctionDecl * decl ) {
+                if (decl->linkage == ast::Linkage::Intrinsic) visit_children = false;
                 GuardValue( funcDecl ) = decl;
         }

src/InitTweak/module.mk

@@ -10 +10 @@
 ## Author           : Richard C. Bilson
 ## Created On       : Mon Jun  1 17:49:17 2015
-## Last Modified By : Rob Schluntz
-## Last Modified On : Fri May 13 11:36:24 2016
-## Update Count     : 3
+## Last Modified By : Andrew Beach
+## Last Modified On : Tue May 17 14:31:00 2022
+## Update Count     : 4
 ###############################################################################
 
-SRC += \
-        InitTweak/FixGlobalInit.cc \
-        InitTweak/FixGlobalInit.h \
-        InitTweak/FixInit.cc \
-        InitTweak/FixInit.h \
-        InitTweak/GenInit.cc \
-        InitTweak/GenInit.h \
-        InitTweak/InitTweak.cc \
-        InitTweak/InitTweak.h \
-        InitTweak/FixInitNew.cpp
-
-SRCDEMANGLE += \
+SRC_INITTWEAK = \
         InitTweak/GenInit.cc \
         InitTweak/GenInit.h \
@@ -32 +21 @@
         InitTweak/InitTweak.h
 
+SRC += $(SRC_INITTWEAK) \
+        InitTweak/FixGlobalInit.cc \
+        InitTweak/FixGlobalInit.h \
+        InitTweak/FixInit.cc \
+        InitTweak/FixInit.h \
+        InitTweak/FixInitNew.cpp
+
+SRCDEMANGLE += $(SRC_INITTWEAK)

src/Parser/parser.yy

@@ -10 +10 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed May  4 17:22:48 2022
-// Update Count     : 5279
+// Last Modified On : Sat May 14 09:16:22 2022
+// Update Count     : 5401
 //
 
@@ -54 +54 @@
 #include "Common/SemanticError.h"                                               // error_str
 #include "Common/utility.h"                                                             // for maybeMoveBuild, maybeBuild, CodeLo...
+
+#include "SynTree/Attribute.h"     // for Attribute
 
 extern DeclarationNode * parseTree;
@@ -93 +95 @@
 } // appendStr
 
-DeclarationNode * distAttr( DeclarationNode * specifier, DeclarationNode * declList ) {
-        // distribute declaration_specifier across all declared variables, e.g., static, const, __attribute__.
-        DeclarationNode * cur = declList, * cl = (new DeclarationNode)->addType( specifier );
+DeclarationNode * distAttr( DeclarationNode * typeSpec, DeclarationNode * declList ) {
+        // distribute declaration_specifier across all declared variables, e.g., static, const, but not __attribute__.
+        assert( declList );
+//      printf( "distAttr1 typeSpec %p\n", typeSpec ); typeSpec->print( std::cout );
+        DeclarationNode * cur = declList, * cl = (new DeclarationNode)->addType( typeSpec );
+//      printf( "distAttr2 cl %p\n", cl ); cl->type->print( std::cout );
+//      cl->type->aggregate.name = cl->type->aggInst.aggregate->aggregate.name;
+
         for ( cur = dynamic_cast<DeclarationNode *>( cur->get_next() ); cur != nullptr; cur = dynamic_cast<DeclarationNode *>( cur->get_next() ) ) {
                 cl->cloneBaseType( cur );
         } // for
         declList->addType( cl );
+//      printf( "distAttr3 declList %p\n", declList ); declList->print( std::cout, 0 );
         return declList;
 } // distAttr
@@ -171 +179 @@
                 if ( ! ( typeSpec->type && (typeSpec->type->kind == TypeData::Aggregate || typeSpec->type->kind == TypeData::Enum) ) ) {
                         stringstream ss;
-                        typeSpec->type->print( ss );
+                        // printf( "fieldDecl1 typeSpec %p\n", typeSpec ); typeSpec->type->print( std::cout );
                         SemanticWarning( yylloc, Warning::SuperfluousDecl, ss.str().c_str() );
                         return nullptr;
                 } // if
+                // printf( "fieldDecl2 typeSpec %p\n", typeSpec ); typeSpec->type->print( std::cout );
                 fieldList = DeclarationNode::newName( nullptr );
         } // if
-        return distAttr( typeSpec, fieldList );                         // mark all fields in list
+//      return distAttr( typeSpec, fieldList );                         // mark all fields in list
+
+        // printf( "fieldDecl3 typeSpec %p\n", typeSpec ); typeSpec->print( std::cout, 0 );
+        DeclarationNode * temp = distAttr( typeSpec, fieldList );                               // mark all fields in list
+        // printf( "fieldDecl4 temp %p\n", temp ); temp->print( std::cout, 0 );
+        return temp;
 } // fieldDecl
 
@@ -1620 +1634 @@
 declaration:                                                                                    // old & new style declarations
         c_declaration ';'
+                {
+                        // printf( "C_DECLARATION1 %p %s\n", $$, $$->name ? $$->name->c_str() : "(nil)" );
+                        // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
+                        //   printf( "\tattr %s\n", attr->name.c_str() );
+                        // } // for
+                }
         | cfa_declaration ';'                                                           // CFA
         | static_assert                                                                         // C11
@@ -1825 +1845 @@
         basic_type_specifier
         | sue_type_specifier
+                {
+                        // printf( "sue_type_specifier2 %p %s\n", $$, $$->type->aggregate.name ? $$->type->aggregate.name->c_str() : "(nil)" );
+                        // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
+                        //   printf( "\tattr %s\n", attr->name.c_str() );
+                        // } // for
+                }
         | type_type_specifier
         ;
@@ -2041 +2067 @@
 sue_declaration_specifier:                                                              // struct, union, enum + storage class + type specifier
         sue_type_specifier
+                {
+                        // printf( "sue_declaration_specifier %p %s\n", $$, $$->type->aggregate.name ? $$->type->aggregate.name->c_str() : "(nil)" );
+                        // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
+                        //   printf( "\tattr %s\n", attr->name.c_str() );
+                        // } // for
+                }
         | declaration_qualifier_list sue_type_specifier
                 { $$ = $2->addQualifiers( $1 ); }
@@ -2051 +2083 @@
 sue_type_specifier:                                                                             // struct, union, enum + type specifier
         elaborated_type
+                {
+                        // printf( "sue_type_specifier %p %s\n", $$, $$->type->aggregate.name ? $$->type->aggregate.name->c_str() : "(nil)" );
+                        // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
+                        //   printf( "\tattr %s\n", attr->name.c_str() );
+                        // } // for
+                }
         | type_qualifier_list
                 { if ( $1->type != nullptr && $1->type->forall ) forall = true; } // remember generic type
@@ -2123 +2161 @@
 elaborated_type:                                                                                // struct, union, enum
         aggregate_type
+                {
+                        // printf( "elaborated_type %p %s\n", $$, $$->type->aggregate.name ? $$->type->aggregate.name->c_str() : "(nil)" );
+                        // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
+                        //   printf( "\tattr %s\n", attr->name.c_str() );
+                        // } // for
+                }
         | enum_type
         ;
@@ -2142 +2186 @@
                 }
           '{' field_declaration_list_opt '}' type_parameters_opt
-                { $$ = DeclarationNode::newAggregate( $1, $3, $8, $6, true )->addQualifiers( $2 ); }
+                {
+                        // printf( "aggregate_type1 %s\n", $3.str->c_str() );
+                        // if ( $2 )
+                        //      for ( Attribute * attr: reverseIterate( $2->attributes ) ) {
+                        //              printf( "copySpecifiers12 %s\n", attr->name.c_str() );
+                        //      } // for
+                        $$ = DeclarationNode::newAggregate( $1, $3, $8, $6, true )->addQualifiers( $2 );
+                        // printf( "aggregate_type2 %p %s\n", $$, $$->type->aggregate.name ? $$->type->aggregate.name->c_str() : "(nil)" );
+                        // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
+                        //      printf( "aggregate_type3 %s\n", attr->name.c_str() );
+                        // } // for
+                }
         | aggregate_key attribute_list_opt TYPEDEFname          // unqualified type name
                 {
@@ -2150 +2205 @@
           '{' field_declaration_list_opt '}' type_parameters_opt
                 {
+                        // printf( "AGG3\n" );
                         DeclarationNode::newFromTypedef( $3 );
                         $$ = DeclarationNode::newAggregate( $1, $3, $8, $6, true )->addQualifiers( $2 );
@@ -2160 +2216 @@
           '{' field_declaration_list_opt '}' type_parameters_opt
                 {
+                        // printf( "AGG4\n" );
                         DeclarationNode::newFromTypeGen( $3, nullptr );
                         $$ = DeclarationNode::newAggregate( $1, $3, $8, $6, true )->addQualifiers( $2 );
@@ -2236 +2293 @@
 field_declaration:
         type_specifier field_declaring_list_opt ';'
-                { $$ = fieldDecl( $1, $2 ); }
+                {
+                        // printf( "type_specifier1 %p %s\n", $$, $$->type->aggregate.name ? $$->type->aggregate.name->c_str() : "(nil)" );
+                        $$ = fieldDecl( $1, $2 );
+                        // printf( "type_specifier2 %p %s\n", $$, $$->type->aggregate.name ? $$->type->aggregate.name->c_str() : "(nil)" );
+                        // for ( Attribute * attr: reverseIterate( $$->attributes ) ) {
+                        //   printf( "\tattr %s\n", attr->name.c_str() );
+                        // } // for
+                }
         | EXTENSION type_specifier field_declaring_list_opt ';' // GCC
                 { $$ = fieldDecl( $2, $3 ); distExt( $$ ); }
@@ -2845 +2909 @@
         // empty
                 { $$ = nullptr; forall = false; }
-        | WITH '(' tuple_expression_list ')'
-                { $$ = $3; forall = false; }
+        | WITH '(' tuple_expression_list ')' attribute_list_opt
+                {
+                        $$ = $3; forall = false;
+                        if ( $5 ) {
+                                SemanticError( yylloc, "Attributes cannot be associated with function body. Move attribute(s) before \"with\" clause." );
+                                $$ = nullptr;
+                        } // if
+                }
         ;
 

src/ResolvExpr/AlternativeFinder.cc

@@ -42 +42 @@
 #include "SymTab/Indexer.h"        // for Indexer
 #include "SymTab/Mangler.h"        // for Mangler
-#include "SymTab/Validate.h"       // for validateType
+#include "SymTab/ValidateType.h"   // for validateType
 #include "SynTree/Constant.h"      // for Constant
 #include "SynTree/Declaration.h"   // for DeclarationWithType, TypeDecl, Dec...

src/ResolvExpr/CandidateFinder.cpp

@@ -899 +899 @@
 
                                                 if (argType.as<ast::PointerType>()) funcFinder.otypeKeys.insert(Mangle::Encoding::pointer);
+                                                else if (const ast::EnumInstType * enumInst = argType.as<ast::EnumInstType>()) {
+                                                        const ast::EnumDecl * enumDecl = enumInst->base;
+                                                        if ( const ast::Type* enumType = enumDecl->base ) {
+                                                                // instance of enum (T) is a instance of type (T) 
+                                                                funcFinder.otypeKeys.insert(Mangle::mangle(enumType, Mangle::NoGenericParams | Mangle::Type));
+                                                        } else {
+                                                                // instance of an untyped enum is techically int
+                                                                funcFinder.otypeKeys.insert(Mangle::mangle(enumDecl, Mangle::NoGenericParams | Mangle::Type));
+                                                        }
+                                                } 
                                                 else funcFinder.otypeKeys.insert(Mangle::mangle(argType, Mangle::NoGenericParams | Mangle::Type));
                                         }
@@ -918 +928 @@
 
                         // find function operators
-                        ast::ptr< ast::Expr > opExpr = new ast::NameExpr{ untypedExpr->location, "?()" };
+                        ast::ptr< ast::Expr > opExpr = new ast::NameExpr{ untypedExpr->location, "?()" }; // ??? why not ?{}
                         CandidateFinder opFinder( context, tenv );
                         // okay if there aren't any function operations

src/ResolvExpr/CommonType.cc

@@ -497 +497 @@
                                 result = new BasicType( basicType->tq | otherBasic->tq, newType );
                         } // if
-                } else if ( dynamic_cast< EnumInstType * > ( type2 ) || dynamic_cast< ZeroType * >( type2 ) || dynamic_cast< OneType * >( type2 ) ) {
+                } else if (  dynamic_cast< ZeroType * >( type2 ) || dynamic_cast< OneType * >( type2 ) ) {
                         // use signed int in lieu of the enum/zero/one type
                         BasicType::Kind newType = commonTypes[ basicType->get_kind() ][ BasicType::SignedInt ];
@@ -503 +503 @@
                                 result = new BasicType( basicType->tq | type2->tq, newType );
                         } // if
-                } // if
+                } else if ( const EnumInstType * enumInst = dynamic_cast< const EnumInstType * > ( type2 ) ) {
+                        const EnumDecl* enumDecl = enumInst->baseEnum;
+                        if ( const Type* baseType = enumDecl->base ) {
+                                result = baseType->clone();
+                        } else {
+                                BasicType::Kind newType = commonTypes[ basicType->get_kind() ][ BasicType::SignedInt ];
+                                if ( ( ( newType == basicType->get_kind() && basicType->tq >= type2->tq ) || widenFirst ) && ( ( newType != basicType->get_kind() && basicType->tq <= type2->tq ) || widenSecond ) ) {
+                                        result = new BasicType( basicType->tq | type2->tq, newType );
+                                } // if
+                        }
+                }
         }
 
@@ -691 +701 @@
                                 }
                         } else if (
-                                dynamic_cast< const ast::EnumInstType * >( type2 )
-                                || dynamic_cast< const ast::ZeroType * >( type2 )
+                                dynamic_cast< const ast::ZeroType * >( type2 )
                                 || dynamic_cast< const ast::OneType * >( type2 )
                         ) {
@@ -705 +714 @@
                                         result = new ast::BasicType{ kind, basic->qualifiers | type2->qualifiers };
                                 }
+                        } else if ( const ast::EnumInstType * enumInst = dynamic_cast< const ast::EnumInstType * >( type2 ) ) {
+                                #warning remove casts when `commonTypes` moved to new AST
+                                const ast::EnumDecl* enumDecl = enumInst->base;
+                                if ( enumDecl->base ) {
+                                        result = enumDecl->base.get();
+                                } else {
+                                        ast::BasicType::Kind kind = (ast::BasicType::Kind)(int)commonTypes[ (BasicType::Kind)(int)basic->kind ][ (BasicType::Kind)(int)ast::BasicType::SignedInt ];
+                                        if (
+                                                ( ( kind == basic->kind && basic->qualifiers >= type2->qualifiers )
+                                                        || widen.first )
+                                                && ( ( kind != basic->kind && basic->qualifiers <= type2->qualifiers )
+                                                        || widen.second )
+                                        ) {
+                                                result = new ast::BasicType{ kind, basic->qualifiers | type2->qualifiers };
+                                        }
+                                }
                         }
                 }
@@ -723 +748 @@
                         result = voidPtr;
                         add_qualifiers( result, oPtr->qualifiers );
+                }
+
+                // For a typed enum, we want to unify type1 with the base type of the enum
+                bool tryResolveWithTypedEnum( const ast::Type * type1 ) {
+                        if (auto enumInst = dynamic_cast<const ast::EnumInstType *> (type2) ) {
+                                ast::AssertionSet have, need; // unused
+                                ast::OpenVarSet newOpen{ open };
+                                if (enumInst->base->base 
+                                && unifyExact(type1, enumInst->base->base, tenv, need, have, newOpen, widen, symtab)) {
+                                        result = type1;
+                                        return true;
+                                }
+                        }
+                        return false;
                 }
 
@@ -768 +807 @@
                                 result = pointer;
                                 add_qualifiers( result, type2->qualifiers );
-                        }
-                }
-
-                void postvisit( const ast::ArrayType * ) {}
+                        } else {
+                                tryResolveWithTypedEnum( pointer );
+                        }
+                }
+
+                void postvisit( const ast::ArrayType * arr ) {
+                        // xxx - does it make sense? 
+                        tryResolveWithTypedEnum( arr );
+                }
 
                 void postvisit( const ast::ReferenceType * ref ) {
@@ -810 +854 @@
                                 result = ref;
                                 add_qualifiers( result, type2->qualifiers );
-                        }
-                }
-
-                void postvisit( const ast::FunctionType * ) {}
-
-                void postvisit( const ast::StructInstType * ) {}
-
-                void postvisit( const ast::UnionInstType * ) {}
+                        } else {
+                                // xxx - does unifying a ref with typed enumInst makes sense?
+                                if (!dynamic_cast<const ast::EnumInstType *>(type2))
+                                        result = commonType( type2, ref, widen, symtab, tenv, open );
+                        }
+                }
+
+                void postvisit( const ast::FunctionType * func) {
+                        tryResolveWithTypedEnum( func ); 
+                }
+
+                void postvisit( const ast::StructInstType * inst ) {
+                        tryResolveWithTypedEnum( inst );
+                }
+
+                void postvisit( const ast::UnionInstType * inst ) {
+                        tryResolveWithTypedEnum( inst );
+                }
 
                 void postvisit( const ast::EnumInstType * enumInst ) {
-                        if (
-                                dynamic_cast< const ast::BasicType * >( type2 )
-                                || dynamic_cast< const ast::ZeroType * >( type2 )
-                                || dynamic_cast< const ast::OneType * >( type2 )
-                        ) {
-                                // reuse BasicType/EnumInstType common type by swapping
+                        // reuse BasicType/EnumInstType common type by swapping
+                        // xxx - is this already handled by unify?
+                        if (!dynamic_cast<const ast::EnumInstType *>(type2))
                                 result = commonType( type2, enumInst, widen, symtab, tenv, open );
-                        }
                 }
 
@@ -850 +900 @@
                                                 result = type2;
                                                 reset_qualifiers( result, q1 | q2 );
+                                        } else {
+                                                tryResolveWithTypedEnum( t1 );
                                         }
                                 }
@@ -855 +907 @@
                 }
 
-                void postvisit( const ast::TupleType * ) {}
+                void postvisit( const ast::TupleType * tuple) {
+                        tryResolveWithTypedEnum( tuple );
+                }
 
                 void postvisit( const ast::VarArgsType * ) {}
@@ -861 +915 @@
                 void postvisit( const ast::ZeroType * zero ) {
                         if ( ! widen.first ) return;
-                        if (
-                                dynamic_cast< const ast::BasicType * >( type2 )
-                                || dynamic_cast< const ast::PointerType * >( type2 )
-                                || dynamic_cast< const ast::EnumInstType * >( type2 )
-                        ) {
+                        if ( dynamic_cast< const ast::BasicType * >( type2 )
+                                || dynamic_cast< const ast::PointerType * >( type2 ) ) {
                                 if ( widen.second || zero->qualifiers <= type2->qualifiers ) {
                                         result = type2;
@@ -873 +924 @@
                                 result = new ast::BasicType{
                                         ast::BasicType::SignedInt, zero->qualifiers | type2->qualifiers };
+                        } else if ( const ast::EnumInstType * enumInst = dynamic_cast< const ast::EnumInstType * >( type2 ) ) {
+                                const ast::EnumDecl * enumDecl = enumInst->base;
+                                if ( enumDecl->base ) {
+                                        if ( tryResolveWithTypedEnum( zero ) ) 
+                                                add_qualifiers( result, zero->qualifiers );
+                                } else {
+                                        if ( widen.second || zero->qualifiers <= type2->qualifiers ) {
+                                                result = type2;
+                                                add_qualifiers( result, zero->qualifiers );
+                                        }
+                                }
                         }
                 }
@@ -878 +940 @@
                 void postvisit( const ast::OneType * one ) {
                         if ( ! widen.first ) return;
-                        if (
-                                dynamic_cast< const ast::BasicType * >( type2 )
-                                || dynamic_cast< const ast::EnumInstType * >( type2 )
-                        ) {
+                        if ( dynamic_cast< const ast::BasicType * >( type2 ) ) {
                                 if ( widen.second || one->qualifiers <= type2->qualifiers ) {
                                         result = type2;
@@ -889 +948 @@
                                 result = new ast::BasicType{
                                         ast::BasicType::SignedInt, one->qualifiers | type2->qualifiers };
+                        } else if ( const ast::EnumInstType * enumInst = dynamic_cast< const ast::EnumInstType * >( type2 ) ) {
+                                const ast::EnumDecl * enumBase = enumInst->base;
+                                if ( enumBase->base ) {
+                                        if ( tryResolveWithTypedEnum( one ))
+                                                add_qualifiers( result, one->qualifiers );
+                                } else {
+                                        if ( widen.second || one->qualifiers <= type2->qualifiers ) {
+                                                result = type2;
+                                                add_qualifiers( result, one->qualifiers );
+                                        }
+                                }
                         }
                 }

src/ResolvExpr/ConversionCost.cc

@@ -321 +321 @@
         }
 
+        // refactor for code resue
+        void ConversionCost::conversionCostFromBasicToBasic(const BasicType * src, const BasicType * dest) {
+                int tableResult = costMatrix[ src->kind ][ dest->kind ];
+                if ( tableResult == -1 ) {
+                        cost = Cost::unsafe;
+                } else {
+                        cost = Cost::zero;
+                        cost.incSafe( tableResult );
+                        cost.incSign( signMatrix[ src->kind ][ dest->kind ] );
+                } // if
+        } // ConversionCost::conversionCostFromBasicToBasic
+
         void ConversionCost::postvisit(const BasicType * basicType) {
                 if ( const BasicType * destAsBasic = dynamic_cast< const BasicType * >( dest ) ) {
-                        int tableResult = costMatrix[ basicType->kind ][ destAsBasic->kind ];
-                        if ( tableResult == -1 ) {
-                                cost = Cost::unsafe;
-                        } else {
-                                cost = Cost::zero;
-                                cost.incSafe( tableResult );
-                                cost.incSign( signMatrix[ basicType->kind ][ destAsBasic->kind ] );
-                        } // if
-                } else if ( dynamic_cast< const EnumInstType * >( dest ) ) {
-                        // xxx - not positive this is correct, but appears to allow casting int => enum
-                        // TODO
-                        EnumDecl * decl = dynamic_cast< const EnumInstType * >( dest )->baseEnum;
-                        if ( decl->base ) {
-                                cost = Cost::infinity;
+                        conversionCostFromBasicToBasic(basicType, destAsBasic);
+                } else if ( const EnumInstType * enumInst = dynamic_cast< const EnumInstType * >( dest ) ) {
+                        const EnumDecl * base_enum = enumInst->baseEnum;
+                        if ( const Type * base = base_enum->base ) { // if the base enum has a base (if it is typed)
+                                if ( const BasicType * enumBaseAstBasic = dynamic_cast< const BasicType *> (base) ) {
+                                        conversionCostFromBasicToBasic(basicType, enumBaseAstBasic);
+                                } else {
+                                        cost = Cost::infinity;
+                                } // if
                         } else {
                                 cost = Cost::unsafe;
@@ -398 +405 @@
         void ConversionCost::postvisit( const FunctionType * ) {}
 
-        void ConversionCost::postvisit( const EnumInstType * ) {
-                static Type::Qualifiers q;
-                static BasicType integer( q, BasicType::SignedInt );
-                cost = costFunc( &integer, dest, srcIsLvalue, indexer, env );  // safe if dest >= int
+        void ConversionCost::postvisit( const EnumInstType * enumInst) {
+                const EnumDecl * enumDecl = enumInst -> baseEnum;
+                if ( const Type * enumType = enumDecl -> base ) { // if it is a typed enum
+                        cost = costFunc( enumType, dest, srcIsLvalue, indexer, env );
+                } else {
+                        static Type::Qualifiers q;
+                        static BasicType integer( q, BasicType::SignedInt );
+                        cost = costFunc( &integer, dest, srcIsLvalue, indexer, env );  // safe if dest >= int
+                } // if
                 if ( cost < Cost::unsafe ) {
-                        cost.incSafe();
+                                cost.incSafe();
                 } // if
         }
@@ -604 +616 @@
 }
 
+void ConversionCost_new::conversionCostFromBasicToBasic( const ast::BasicType * src, const ast::BasicType* dest ) {
+        int tableResult = costMatrix[ src->kind ][ dest->kind ];
+        if ( tableResult == -1 ) {
+                cost = Cost::unsafe;
+        } else {
+                cost = Cost::zero;
+                cost.incSafe( tableResult );
+                cost.incSign( signMatrix[ src->kind ][ dest->kind ] );
+        }
+}
+
 void ConversionCost_new::postvisit( const ast::BasicType * basicType ) {
         if ( const ast::BasicType * dstAsBasic = dynamic_cast< const ast::BasicType * >( dst ) ) {
-                int tableResult = costMatrix[ basicType->kind ][ dstAsBasic->kind ];
-                if ( tableResult == -1 ) {
-                        cost = Cost::unsafe;
-                } else {
-                        cost = Cost::zero;
-                        cost.incSafe( tableResult );
-                        cost.incSign( signMatrix[ basicType->kind ][ dstAsBasic->kind ] );
-                }
-        } else if ( dynamic_cast< const ast::EnumInstType * >( dst ) ) {
-                // xxx - not positive this is correct, but appears to allow casting int => enum
-                const ast::EnumDecl * decl = (dynamic_cast< const ast::EnumInstType * >( dst ))->base.get();
-                if ( decl->base ) {
-                        cost = Cost::infinity;
-                } else {
-                        cost = Cost::unsafe;
-                } // if
+                conversionCostFromBasicToBasic( basicType, dstAsBasic );
+        } else if ( const ast::EnumInstType * enumInst = dynamic_cast< const ast::EnumInstType * >( dst ) ) {
+                const ast::EnumDecl * enumDecl = enumInst->base.get();
+                if ( const ast::Type * enumType = enumDecl->base.get() ) {
+                        if ( const ast::BasicType * enumTypeAsBasic = dynamic_cast<const ast::BasicType *>(enumType) ) {
+                                conversionCostFromBasicToBasic( basicType, enumTypeAsBasic );
+                        } else {
+                                cost = Cost::infinity;
+                        }
+                } else {
+            cost = Cost::unsafe;
+                }
         }
 }
@@ -673 +692 @@
 
 void ConversionCost_new::postvisit( const ast::EnumInstType * enumInstType ) {
-        (void)enumInstType;
-        static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicType::SignedInt ) };
-        cost = costCalc( integer, dst, srcIsLvalue, symtab, env );
+        const ast::EnumDecl * baseEnum = enumInstType->base;
+        if ( const ast::Type * baseType = baseEnum->base ) {
+                cost = costCalc( baseType, dst, srcIsLvalue, symtab, env );
+        } else {
+                (void)enumInstType;
+                static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicType::SignedInt ) };
+                cost = costCalc( integer, dst, srcIsLvalue, symtab, env );
+        }
         if ( cost < Cost::unsafe ) {
                 cost.incSafe();

src/ResolvExpr/ConversionCost.h

@@ -65 +65 @@
                 const TypeEnvironment &env;
                 CostFunction costFunc;
+          private:
+                // refactor for code resue
+                void conversionCostFromBasicToBasic( const BasicType * src, const BasicType* dest );
         };
 
@@ -111 +114 @@
         void postvisit( const ast::ZeroType * zeroType );
         void postvisit( const ast::OneType * oneType );
+private:
+        // refactor for code resue
+        void conversionCostFromBasicToBasic( const ast::BasicType * src, const ast::BasicType* dest );
 };
 

src/SymTab/Autogen.h

@@ -21 +21 @@
 
 #include "AST/Decl.hpp"
-#include "AST/Eval.hpp"
 #include "AST/Expr.hpp"
 #include "AST/Init.hpp"
@@ -71 +70 @@
         template< typename OutIter >
         ast::ptr< ast::Stmt > genCall(
-                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam, 
-                const CodeLocation & loc, const std::string & fname, OutIter && out, 
+                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam,
+                const CodeLocation & loc, const std::string & fname, OutIter && out,
                 const ast::Type * type, const ast::Type * addCast, LoopDirection forward = LoopForward );
 
@@ -128 +127 @@
         }
 
-        /// inserts into out a generated call expression to function fname with arguments dstParam and 
+        /// inserts into out a generated call expression to function fname with arguments dstParam and
         /// srcParam. Should only be called with non-array types.
-        /// optionally returns a statement which must be inserted prior to the containing loop, if 
+        /// optionally returns a statement which must be inserted prior to the containing loop, if
         /// there is one
         template< typename OutIter >
-        ast::ptr< ast::Stmt > genScalarCall( 
-                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam, 
-                const CodeLocation & loc, std::string fname, OutIter && out, const ast::Type * type, 
+        ast::ptr< ast::Stmt > genScalarCall(
+                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam,
+                const CodeLocation & loc, std::string fname, OutIter && out, const ast::Type * type,
                 const ast::Type * addCast = nullptr
         ) {
@@ -153 +152 @@
 
                 if ( addCast ) {
-                        // cast to T& with qualifiers removed, so that qualified objects can be constructed and 
-                        // destructed with the same functions as non-qualified objects. Unfortunately, lvalue 
-                        // is considered a qualifier - for AddressExpr to resolve, its argument must have an 
+                        // cast to T& with qualifiers removed, so that qualified objects can be constructed and
+                        // destructed with the same functions as non-qualified objects. Unfortunately, lvalue
+                        // is considered a qualifier - for AddressExpr to resolve, its argument must have an
                         // lvalue-qualified type, so remove all qualifiers except lvalue.
                         // xxx -- old code actually removed lvalue too...
                         ast::ptr< ast::Type > guard = addCast;  // prevent castType from mutating addCast
                         ast::ptr< ast::Type > castType = addCast;
-                        ast::remove_qualifiers( 
-                                castType, 
+                        ast::remove_qualifiers(
+                                castType,
                                 ast::CV::Const | ast::CV::Volatile | ast::CV::Restrict | ast::CV::Atomic );
                         dstParam = new ast::CastExpr{ dstParam, new ast::ReferenceType{ castType } };
@@ -181 +180 @@
 
                 srcParam.clearArrayIndices();
-                
+
                 return listInit;
         }
@@ -249 +248 @@
         }
 
-        /// Store in out a loop which calls fname on each element of the array with srcParam and 
+        /// Store in out a loop which calls fname on each element of the array with srcParam and
         /// dstParam as arguments. If forward is true, loop goes from 0 to N-1, else N-1 to 0
         template< typename OutIter >
         void genArrayCall(
-                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam, 
-                const CodeLocation & loc, const std::string & fname, OutIter && out, 
-                const ast::ArrayType * array, const ast::Type * addCast = nullptr, 
-                LoopDirection forward = LoopForward 
+                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam,
+                const CodeLocation & loc, const std::string & fname, OutIter && out,
+                const ast::ArrayType * array, const ast::Type * addCast = nullptr,
+                LoopDirection forward = LoopForward
         ) {
                 static UniqueName indexName( "_index" );
@@ -279 +278 @@
                 } else {
                         // generate: for ( int i = N-1; i >= 0; --i )
-                        begin = ast::call( 
-                                loc, "?-?", array->dimension, ast::ConstantExpr::from_int( loc, 1 ) );
+                        begin = ast::UntypedExpr::createCall( loc, "?-?",
+                                { array->dimension, ast::ConstantExpr::from_int( loc, 1 ) } );
                         end = ast::ConstantExpr::from_int( loc, 0 );
                         cmp = "?>=?";
@@ -286 +285 @@
                 }
 
-                ast::ptr< ast::DeclWithType > index = new ast::ObjectDecl{ 
-                        loc, indexName.newName(), new ast::BasicType{ ast::BasicType::SignedInt }, 
+                ast::ptr< ast::DeclWithType > index = new ast::ObjectDecl{
+                        loc, indexName.newName(), new ast::BasicType{ ast::BasicType::SignedInt },
                         new ast::SingleInit{ loc, begin } };
                 ast::ptr< ast::Expr > indexVar = new ast::VariableExpr{ loc, index };
-                
-                ast::ptr< ast::Expr > cond = ast::call( loc, cmp, indexVar, end );
-                
-                ast::ptr< ast::Expr > inc = ast::call( loc, update, indexVar );
-                
-                ast::ptr< ast::Expr > dstIndex = ast::call( loc, "?[?]", dstParam, indexVar );
-                
-                // srcParam must keep track of the array indices to build the source parameter and/or 
+
+                ast::ptr< ast::Expr > cond = ast::UntypedExpr::createCall(
+                        loc, cmp, { indexVar, end } );
+
+                ast::ptr< ast::Expr > inc = ast::UntypedExpr::createCall(
+                        loc, update, { indexVar } );
+
+                ast::ptr< ast::Expr > dstIndex = ast::UntypedExpr::createCall(
+                        loc, "?[?]", { dstParam, indexVar } );
+
+                // srcParam must keep track of the array indices to build the source parameter and/or
                 // array list initializer
                 srcParam.addArrayIndex( indexVar, array->dimension );
@@ -303 +305 @@
                 // for stmt's body, eventually containing call
                 ast::CompoundStmt * body = new ast::CompoundStmt{ loc };
-                ast::ptr< ast::Stmt > listInit = genCall( 
-                        srcParam, dstIndex, loc, fname, std::back_inserter( body->kids ), array->base, addCast, 
+                ast::ptr< ast::Stmt > listInit = genCall(
+                        srcParam, dstIndex, loc, fname, std::back_inserter( body->kids ), array->base, addCast,
                         forward );
-                
+
                 // block containing the stmt and index variable
                 ast::CompoundStmt * block = new ast::CompoundStmt{ loc };
@@ -328 +330 @@
         template< typename OutIter >
         ast::ptr< ast::Stmt > genCall(
-                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam, 
-                const CodeLocation & loc, const std::string & fname, OutIter && out, 
+                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam,
+                const CodeLocation & loc, const std::string & fname, OutIter && out,
                 const ast::Type * type, const ast::Type * addCast, LoopDirection forward
         ) {
                 if ( auto at = dynamic_cast< const ast::ArrayType * >( type ) ) {
-                        genArrayCall( 
-                                srcParam, dstParam, loc, fname, std::forward< OutIter >(out), at, addCast, 
+                        genArrayCall(
+                                srcParam, dstParam, loc, fname, std::forward< OutIter >(out), at, addCast,
                                 forward );
                         return {};
                 } else {
-                        return genScalarCall( 
+                        return genScalarCall(
                                 srcParam, dstParam, loc, fname, std::forward< OutIter >( out ), type, addCast );
                 }
@@ -377 +379 @@
         }
 
-        static inline ast::ptr< ast::Stmt > genImplicitCall( 
-                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam, 
-                const CodeLocation & loc, const std::string & fname, const ast::ObjectDecl * obj, 
-                LoopDirection forward = LoopForward 
+        static inline ast::ptr< ast::Stmt > genImplicitCall(
+                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam,
+                const CodeLocation & loc, const std::string & fname, const ast::ObjectDecl * obj,
+                LoopDirection forward = LoopForward
         ) {
                 // unnamed bit fields are not copied as they cannot be accessed
@@ -392 +394 @@
 
                 std::vector< ast::ptr< ast::Stmt > > stmts;
-                genCall( 
+                genCall(
                         srcParam, dstParam, loc, fname, back_inserter( stmts ), obj->type, addCast, forward );
 
@@ -400 +402 @@
                         const ast::Stmt * callStmt = stmts.front();
                         if ( addCast ) {
-                                // implicitly generated ctor/dtor calls should be wrapped so that later passes are 
+                                // implicitly generated ctor/dtor calls should be wrapped so that later passes are
                                 // aware they were generated.
                                 callStmt = new ast::ImplicitCtorDtorStmt{ callStmt->location, callStmt };
@@ -417 +419 @@
 // compile-command: "make install" //
 // End: //
-

src/SymTab/Demangle.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// Demangler.cc --
+// Demangle.cc -- Convert a mangled name into a human readable name.
 //
 // Author           : Rob Schluntz

src/SymTab/Mangler.h

@@ -111 +111 @@
 }
 
-extern "C" {
-        char * cforall_demangle(const char *, int);
-}
-
 // Local Variables: //
 // tab-width: 4 //

src/SymTab/Validate.cc

@@ -10 +10 @@
 // Created On       : Sun May 17 21:50:04 2015
 // Last Modified By : Andrew Beach
-// Last Modified On : Fri Apr 29  9:45:00 2022
-// Update Count     : 365
+// Last Modified On : Tue May 17 14:36:00 2022
+// Update Count     : 366
 //
 
@@ -74 +74 @@
 #include "ResolvExpr/ResolveTypeof.h"  // for resolveTypeof
 #include "SymTab/Autogen.h"            // for SizeType
+#include "SymTab/ValidateType.h"       // for decayEnumsAndPointers, decayFo...
 #include "SynTree/LinkageSpec.h"       // for C
 #include "SynTree/Attribute.h"         // for noAttributes, Attribute
@@ -134 +135 @@
         };
 
-        /// Replaces enum types by int, and function or array types in function parameter and return lists by appropriate pointers.
-        struct EnumAndPointerDecay_old {
-                void previsit( EnumDecl * aggregateDecl );
-                void previsit( FunctionType * func );
-        };
-
-        /// Associates forward declarations of aggregates with their definitions
-        struct LinkReferenceToTypes_old final : public WithIndexer, public WithGuards, public WithVisitorRef<LinkReferenceToTypes_old>, public WithShortCircuiting {
-                LinkReferenceToTypes_old( const Indexer * indexer );
-
-                void postvisit( TypeInstType * typeInst );
-
-                void postvisit( EnumInstType * enumInst );
-                void postvisit( StructInstType * structInst );
-                void postvisit( UnionInstType * unionInst );
-                void postvisit( TraitInstType * traitInst );
-                void previsit( QualifiedType * qualType );
-                void postvisit( QualifiedType * qualType );
-
-                void postvisit( EnumDecl * enumDecl );
-                void postvisit( StructDecl * structDecl );
-                void postvisit( UnionDecl * unionDecl );
-                void postvisit( TraitDecl * traitDecl );
-
-                void previsit( StructDecl * structDecl );
-                void previsit( UnionDecl * unionDecl );
-
-                void renameGenericParams( std::list< TypeDecl * > & params );
-
-          private:
-                const Indexer * local_indexer;
-
-                typedef std::map< std::string, std::list< EnumInstType * > > ForwardEnumsType;
-                typedef std::map< std::string, std::list< StructInstType * > > ForwardStructsType;
-                typedef std::map< std::string, std::list< UnionInstType * > > ForwardUnionsType;
-                ForwardEnumsType forwardEnums;
-                ForwardStructsType forwardStructs;
-                ForwardUnionsType forwardUnions;
-                /// true if currently in a generic type body, so that type parameter instances can be renamed appropriately
-                bool inGeneric = false;
-        };
-
         /// Does early resolution on the expressions that give enumeration constants their values
         struct ResolveEnumInitializers final : public WithIndexer, public WithGuards, public WithVisitorRef<ResolveEnumInitializers>, public WithShortCircuiting {
@@ -193 +152 @@
                 void previsit( StructDecl * aggrDecl );
                 void previsit( UnionDecl * aggrDecl );
-        };
-
-        // 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 * );
         };
 
@@ -358 +295 @@
 
         void validate_A( std::list< Declaration * > & translationUnit ) {
-                PassVisitor<EnumAndPointerDecay_old> epc;
                 PassVisitor<HoistTypeDecls> hoistDecls;
                 {
@@ -367 +303 @@
                         ReplaceTypedef::replaceTypedef( translationUnit );
                         ReturnTypeFixer::fix( translationUnit ); // must happen before autogen
-                        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
-                }
-        }
-
-        void linkReferenceToTypes( std::list< Declaration * > & translationUnit ) {
-                PassVisitor<LinkReferenceToTypes_old> lrt( nullptr );
-                acceptAll( translationUnit, lrt ); // must happen before autogen, because sized flag needs to propagate to generated functions
+                        decayEnumsAndPointers( translationUnit ); // 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
+                }
         }
 
@@ -412 +343 @@
                         });
                 }
-        }
-
-        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 );
         }
 
@@ -501 +421 @@
         }
 
-        void validateType( Type * type, const Indexer * indexer ) {
-                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;
-                type->accept( epc );
-                type->accept( lrt );
-                type->accept( te );
-                type->accept( af );
-                type->accept( cot );
-                type->accept( fui );
-        }
-
         void HoistTypeDecls::handleType( Type * type ) {
                 // some type declarations are buried in expressions and not easy to hoist during parsing; hoist them here
@@ -708 +613 @@
         }
 
-        void EnumAndPointerDecay_old::previsit( EnumDecl * enumDecl ) {
-                // Set the type of each member of the enumeration to be EnumConstant
-                for ( std::list< Declaration * >::iterator i = enumDecl->members.begin(); i != enumDecl->members.end(); ++i ) {
-                        ObjectDecl * obj = dynamic_cast< ObjectDecl * >( * i );
-                        assert( obj );
-                        obj->set_type( new EnumInstType( Type::Qualifiers( Type::Const ), enumDecl->name ) );
-                } // for
-        }
-
-        namespace {
-                template< typename DWTList >
-                void fixFunctionList( DWTList & dwts, bool isVarArgs, FunctionType * func ) {
-                        auto nvals = dwts.size();
-                        bool containsVoid = false;
-                        for ( auto & dwt : dwts ) {
-                                // fix each DWT and record whether a void was found
-                                containsVoid |= fixFunction( dwt );
-                        }
-
-                        // the only case in which "void" is valid is where it is the only one in the list
-                        if ( containsVoid && ( nvals > 1 || isVarArgs ) ) {
-                                SemanticError( func, "invalid type void in function type " );
-                        }
-
-                        // one void is the only thing in the list; remove it.
-                        if ( containsVoid ) {
-                                delete dwts.front();
-                                dwts.clear();
-                        }
-                }
-        }
-
-        void EnumAndPointerDecay_old::previsit( FunctionType * func ) {
-                // Fix up parameters and return types
-                fixFunctionList( func->parameters, func->isVarArgs, func );
-                fixFunctionList( func->returnVals, false, func );
-        }
-
-        LinkReferenceToTypes_old::LinkReferenceToTypes_old( const Indexer * other_indexer ) : WithIndexer( false ) {
-                if ( other_indexer ) {
-                        local_indexer = other_indexer;
-                } else {
-                        local_indexer = &indexer;
-                } // if
-        }
-
-        void LinkReferenceToTypes_old::postvisit( EnumInstType * enumInst ) {
-                const EnumDecl * st = local_indexer->lookupEnum( enumInst->name );
-                // it's not a semantic error if the enum is not found, just an implicit forward declaration
-                if ( st ) {
-                        enumInst->baseEnum = const_cast<EnumDecl *>(st); // Just linking in the node
-                } // if
-                if ( ! st || ! st->body ) {
-                        // use of forward declaration
-                        forwardEnums[ enumInst->name ].push_back( enumInst );
-                } // if
-        }
-        void LinkReferenceToTypes_old::postvisit( StructInstType * structInst ) {
-                const StructDecl * st = local_indexer->lookupStruct( structInst->name );
-                // it's not a semantic error if the struct is not found, just an implicit forward declaration
-                if ( st ) {
-                        structInst->baseStruct = const_cast<StructDecl *>(st); // Just linking in the node
-                } // if
-                if ( ! st || ! st->body ) {
-                        // use of forward declaration
-                        forwardStructs[ structInst->name ].push_back( structInst );
-                } // if
-        }
-
-        void LinkReferenceToTypes_old::postvisit( UnionInstType * unionInst ) {
-                const UnionDecl * un = local_indexer->lookupUnion( unionInst->name );
-                // it's not a semantic error if the union is not found, just an implicit forward declaration
-                if ( un ) {
-                        unionInst->baseUnion = const_cast<UnionDecl *>(un); // Just linking in the node
-                } // if
-                if ( ! un || ! un->body ) {
-                        // use of forward declaration
-                        forwardUnions[ unionInst->name ].push_back( unionInst );
-                } // if
-        }
-
-        void LinkReferenceToTypes_old::previsit( QualifiedType * ) {
-                visit_children = false;
-        }
-
-        void LinkReferenceToTypes_old::postvisit( QualifiedType * qualType ) {
-                // linking only makes sense for the 'oldest ancestor' of the qualified type
-                qualType->parent->accept( * visitor );
-        }
-
-        template< typename Decl >
-        void normalizeAssertions( std::list< Decl * > & assertions ) {
-                // ensure no duplicate trait members after the clone
-                auto pred = [](Decl * d1, Decl * d2) {
-                        // only care if they're equal
-                        DeclarationWithType * dwt1 = dynamic_cast<DeclarationWithType *>( d1 );
-                        DeclarationWithType * dwt2 = dynamic_cast<DeclarationWithType *>( d2 );
-                        if ( dwt1 && dwt2 ) {
-                                if ( dwt1->name == dwt2->name && ResolvExpr::typesCompatible( dwt1->get_type(), dwt2->get_type(), SymTab::Indexer() ) ) {
-                                        // std::cerr << "=========== equal:" << std::endl;
-                                        // std::cerr << "d1: " << d1 << std::endl;
-                                        // std::cerr << "d2: " << d2 << std::endl;
-                                        return false;
-                                }
-                        }
-                        return d1 < d2;
-                };
-                std::set<Decl *, decltype(pred)> unique_members( assertions.begin(), assertions.end(), pred );
-                // if ( unique_members.size() != assertions.size() ) {
-                //      std::cerr << "============different" << std::endl;
-                //      std::cerr << unique_members.size() << " " << assertions.size() << std::endl;
-                // }
-
-                std::list< Decl * > order;
-                order.splice( order.end(), assertions );
-                std::copy_if( order.begin(), order.end(), back_inserter( assertions ), [&]( Decl * decl ) {
-                        return unique_members.count( decl );
-                });
-        }
-
         // expand assertions from trait instance, performing the appropriate type variable substitutions
         template< typename Iterator >
@@ -838 +623 @@
                 // substitute trait decl parameters for instance parameters
                 applySubstitution( inst->baseTrait->parameters.begin(), inst->baseTrait->parameters.end(), inst->parameters.begin(), asserts.begin(), asserts.end(), out );
-        }
-
-        void LinkReferenceToTypes_old::postvisit( TraitDecl * traitDecl ) {
-                if ( traitDecl->name == "sized" ) {
-                        // "sized" is a special trait - flick the sized status on for the type variable
-                        assertf( traitDecl->parameters.size() == 1, "Built-in trait 'sized' has incorrect number of parameters: %zd", traitDecl->parameters.size() );
-                        TypeDecl * td = traitDecl->parameters.front();
-                        td->set_sized( true );
-                }
-
-                // move assertions from type parameters into the body of the trait
-                for ( TypeDecl * td : traitDecl->parameters ) {
-                        for ( DeclarationWithType * assert : td->assertions ) {
-                                if ( TraitInstType * inst = dynamic_cast< TraitInstType * >( assert->get_type() ) ) {
-                                        expandAssertions( inst, back_inserter( traitDecl->members ) );
-                                } else {
-                                        traitDecl->members.push_back( assert->clone() );
-                                }
-                        }
-                        deleteAll( td->assertions );
-                        td->assertions.clear();
-                } // for
-        }
-
-        void LinkReferenceToTypes_old::postvisit( TraitInstType * traitInst ) {
-                // handle other traits
-                const TraitDecl * traitDecl = local_indexer->lookupTrait( traitInst->name );
-                if ( ! traitDecl ) {
-                        SemanticError( traitInst->location, "use of undeclared trait " + traitInst->name );
-                } // if
-                if ( traitDecl->parameters.size() != traitInst->parameters.size() ) {
-                        SemanticError( traitInst, "incorrect number of trait parameters: " );
-                } // if
-                traitInst->baseTrait = const_cast<TraitDecl *>(traitDecl); // Just linking in the node
-
-                // need to carry over the 'sized' status of each decl in the instance
-                for ( auto p : group_iterate( traitDecl->parameters, traitInst->parameters ) ) {
-                        TypeExpr * expr = dynamic_cast< TypeExpr * >( std::get<1>(p) );
-                        if ( ! expr ) {
-                                SemanticError( std::get<1>(p), "Expression parameters for trait instances are currently unsupported: " );
-                        }
-                        if ( TypeInstType * inst = dynamic_cast< TypeInstType * >( expr->get_type() ) ) {
-                                TypeDecl * formalDecl = std::get<0>(p);
-                                TypeDecl * instDecl = inst->baseType;
-                                if ( formalDecl->get_sized() ) instDecl->set_sized( true );
-                        }
-                }
-                // normalizeAssertions( traitInst->members );
-        }
-
-        void LinkReferenceToTypes_old::postvisit( EnumDecl * enumDecl ) {
-                // visit enum members first so that the types of self-referencing members are updated properly
-                // Replace the enum base; right now it works only for StructEnum
-                if ( enumDecl->base && dynamic_cast<TypeInstType*>(enumDecl->base) ) {
-                        std::string baseName = static_cast<TypeInstType*>(enumDecl->base)->name;
-                        const StructDecl * st = local_indexer->lookupStruct( baseName );
-                        if ( st ) {
-                                enumDecl->base = new StructInstType(Type::Qualifiers(),const_cast<StructDecl *>(st)); // Just linking in the node
-                        }
-                }
-                if ( enumDecl->body ) {
-                        ForwardEnumsType::iterator fwds = forwardEnums.find( enumDecl->name );
-                        if ( fwds != forwardEnums.end() ) {
-                                for ( std::list< EnumInstType * >::iterator inst = fwds->second.begin(); inst != fwds->second.end(); ++inst ) {
-                                        (* inst)->baseEnum = enumDecl;
-                                } // for
-                                forwardEnums.erase( fwds );
-                        } // if
-                } // if
-        }
-
-        void LinkReferenceToTypes_old::renameGenericParams( std::list< TypeDecl * > & params ) {
-                // rename generic type parameters uniquely so that they do not conflict with user-defined function forall parameters, e.g.
-                //   forall(otype T)
-                //   struct Box {
-                //     T x;
-                //   };
-                //   forall(otype T)
-                //   void f(Box(T) b) {
-                //     ...
-                //   }
-                // The T in Box and the T in f are different, so internally the naming must reflect that.
-                GuardValue( inGeneric );
-                inGeneric = ! params.empty();
-                for ( TypeDecl * td : params ) {
-                        td->name = "__" + td->name + "_generic_";
-                }
-        }
-
-        void LinkReferenceToTypes_old::previsit( StructDecl * structDecl ) {
-                renameGenericParams( structDecl->parameters );
-        }
-
-        void LinkReferenceToTypes_old::previsit( UnionDecl * unionDecl ) {
-                renameGenericParams( unionDecl->parameters );
-        }
-
-        void LinkReferenceToTypes_old::postvisit( StructDecl * structDecl ) {
-                // visit struct members first so that the types of self-referencing members are updated properly
-                // xxx - need to ensure that type parameters match up between forward declarations and definition (most importantly, number of type parameters and their defaults)
-                if ( structDecl->body ) {
-                        ForwardStructsType::iterator fwds = forwardStructs.find( structDecl->name );
-                        if ( fwds != forwardStructs.end() ) {
-                                for ( std::list< StructInstType * >::iterator inst = fwds->second.begin(); inst != fwds->second.end(); ++inst ) {
-                                        (* inst)->baseStruct = structDecl;
-                                } // for
-                                forwardStructs.erase( fwds );
-                        } // if
-                } // if
-        }
-
-        void LinkReferenceToTypes_old::postvisit( UnionDecl * unionDecl ) {
-                if ( unionDecl->body ) {
-                        ForwardUnionsType::iterator fwds = forwardUnions.find( unionDecl->name );
-                        if ( fwds != forwardUnions.end() ) {
-                                for ( std::list< UnionInstType * >::iterator inst = fwds->second.begin(); inst != fwds->second.end(); ++inst ) {
-                                        (* inst)->baseUnion = unionDecl;
-                                } // for
-                                forwardUnions.erase( fwds );
-                        } // if
-                } // if
-        }
-
-        void LinkReferenceToTypes_old::postvisit( TypeInstType * typeInst ) {
-                // ensure generic parameter instances are renamed like the base type
-                if ( inGeneric && typeInst->baseType ) typeInst->name = typeInst->baseType->name;
-                if ( const NamedTypeDecl * namedTypeDecl = local_indexer->lookupType( typeInst->name ) ) {
-                        if ( const TypeDecl * typeDecl = dynamic_cast< const TypeDecl * >( namedTypeDecl ) ) {
-                                typeInst->set_isFtype( typeDecl->kind == TypeDecl::Ftype );
-                        } // if
-                } // if
         }
 
@@ -997 +651 @@
                                                 }
                                         }
-                                        
                                 }
                         }
@@ -1085 +738 @@
         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();
         }
 

src/SymTab/Validate.h

@@ -10 +10 @@
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 21:53:34 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 22 09:46:07 2017
-// Update Count     : 4
+// Last Modified By : Andrew Beach
+// Last Modified On : Tue May 17 14:35:00 2022
+// Update Count     : 5
 //
 
@@ -33 +33 @@
         /// Normalizes struct and function declarations
         void validate( std::list< Declaration * > &translationUnit, bool doDebug = false );
-        void validateType( Type *type, const Indexer *indexer );
 
         // Sub-passes of validate.
@@ -42 +41 @@
         void validate_E( std::list< Declaration * > &translationUnit );
         void validate_F( std::list< Declaration * > &translationUnit );
-        void linkReferenceToTypes( std::list< Declaration * > &translationUnit );
-
-        const ast::Type * validateType(
-                const CodeLocation & loc, const ast::Type * type, const ast::SymbolTable & symtab );
 } // namespace SymTab
 

src/SymTab/demangler.cc

@@ -1 @@
-#include "Mangler.h"
+#include "Demangle.h"
 #include <iostream>
 #include <fstream>

src/SymTab/module.mk

@@ -11 +11 @@
 ## Created On       : Mon Jun  1 17:49:17 2015
 ## Last Modified By : Andrew Beach
-## Last Modified On : Thr Aug 10 16:08:00 2017
-## Update Count     : 4
+## Last Modified On : Tue May 17 14:46:00 2022
+## Update Count     : 5
 ###############################################################################
 
 SRC_SYMTAB = \
-      SymTab/Autogen.cc \
-      SymTab/Autogen.h \
-      SymTab/FixFunction.cc \
-      SymTab/FixFunction.h \
-      SymTab/Indexer.cc \
-      SymTab/Indexer.h \
-      SymTab/Mangler.cc \
-      SymTab/ManglerCommon.cc \
-      SymTab/Mangler.h \
-      SymTab/Validate.cc \
-      SymTab/Validate.h
+        SymTab/Autogen.cc \
+        SymTab/Autogen.h \
+        SymTab/FixFunction.cc \
+        SymTab/FixFunction.h \
+        SymTab/Indexer.cc \
+        SymTab/Indexer.h \
+        SymTab/Mangler.cc \
+        SymTab/ManglerCommon.cc \
+        SymTab/Mangler.h \
+        SymTab/ValidateType.cc \
+        SymTab/ValidateType.h
 
-SRC += $(SRC_SYMTAB)
-SRCDEMANGLE += $(SRC_SYMTAB) SymTab/Demangle.cc
+SRC += $(SRC_SYMTAB) \
+        SymTab/Validate.cc \
+        SymTab/Validate.h
+
+SRCDEMANGLE += $(SRC_SYMTAB) \
+        SymTab/Demangle.cc \
+        SymTab/Demangle.h

src/SynTree/module.mk

@@ -24 +24 @@
       SynTree/AttrType.cc \
       SynTree/BaseSyntaxNode.h \
+      SynTree/BaseSyntaxNode.cc \
       SynTree/BasicType.cc \
       SynTree/CommaExpr.cc \

src/Tuples/TupleExpansion.cc

@@ -9 +9 @@
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Dec 13 23:45:51 2019
-// Update Count     : 24
+// Last Modified By : Andrew Beach
+// Last Modified On : Tue May 17 15:02:00 2022
+// Update Count     : 25
 //
 
@@ -367 +367 @@
                 return nullptr;
         }
-
-        namespace {
-                /// determines if impurity (read: side-effects) may exist in a piece of code. Currently gives a very crude approximation, wherein any function call expression means the code may be impure
-                struct ImpurityDetector : public WithShortCircuiting {
-                        ImpurityDetector( bool ignoreUnique ) : ignoreUnique( ignoreUnique ) {}
-
-                        void previsit( const ApplicationExpr * appExpr ) {
-                                visit_children = false;
-                                if ( const DeclarationWithType * function = InitTweak::getFunction( appExpr ) ) {
-                                        if ( function->linkage == LinkageSpec::Intrinsic ) {
-                                                if ( function->name == "*?" || function->name == "?[?]" ) {
-                                                        // intrinsic dereference, subscript are pure, but need to recursively look for impurity
-                                                        visit_children = true;
-                                                        return;
-                                                }
-                                        }
-                                }
-                                maybeImpure = true;
-                        }
-                        void previsit( const UntypedExpr * ) { maybeImpure = true; visit_children = false; }
-                        void previsit( const UniqueExpr * ) {
-                                if ( ignoreUnique ) {
-                                        // bottom out at unique expression.
-                                        // The existence of a unique expression doesn't change the purity of an expression.
-                                        // That is, even if the wrapped expression is impure, the wrapper protects the rest of the expression.
-                                        visit_children = false;
-                                        return;
-                                }
-                        }
-
-                        bool maybeImpure = false;
-                        bool ignoreUnique;
-                };
-        } // namespace
-
-        bool maybeImpure( const Expression * expr ) {
-                PassVisitor<ImpurityDetector> detector( false );
-                expr->accept( detector );
-                return detector.pass.maybeImpure;
-        }
-
-        bool maybeImpureIgnoreUnique( const Expression * expr ) {
-                PassVisitor<ImpurityDetector> detector( true );
-                expr->accept( detector );
-                return detector.pass.maybeImpure;
-        }
 } // namespace Tuples
 

src/Tuples/Tuples.cc

@@ -10 +10 @@
 // Created On       : Mon Jun 17 14:41:00 2019
 // Last Modified By : Andrew Beach
-// Last Modified On : Tue Jun 18  9:31:00 2019
-// Update Count     : 1
+// Last Modified On : Mon May 16 16:15:00 2022
+// Update Count     : 2
 //
 
@@ -18 +18 @@
 #include "AST/Pass.hpp"
 #include "AST/LinkageSpec.hpp"
+#include "Common/PassVisitor.h"
 #include "InitTweak/InitTweak.h"
 
@@ -23 +24 @@
 
 namespace {
+        /// Checks if impurity (read: side-effects) may exist in a piece of code.
+        /// Currently gives a very crude approximation, wherein any function
+        /// call expression means the code may be impure.
+        struct ImpurityDetector_old : public WithShortCircuiting {
+                bool const ignoreUnique;
+                bool maybeImpure;
+
+                ImpurityDetector_old( bool ignoreUnique ) :
+                        ignoreUnique( ignoreUnique ), maybeImpure( false )
+                {}
+
+                void previsit( const ApplicationExpr * appExpr ) {
+                        visit_children = false;
+                        if ( const DeclarationWithType * function =
+                                        InitTweak::getFunction( appExpr ) ) {
+                                if ( function->linkage == LinkageSpec::Intrinsic ) {
+                                        if ( function->name == "*?" || function->name == "?[?]" ) {
+                                                // intrinsic dereference, subscript are pure,
+                                                // but need to recursively look for impurity
+                                                visit_children = true;
+                                                return;
+                                        }
+                                }
+                        }
+                        maybeImpure = true;
+                }
+
+                void previsit( const UntypedExpr * ) {
+                        maybeImpure = true;
+                        visit_children = false;
+                }
+
+                void previsit( const UniqueExpr * ) {
+                        if ( ignoreUnique ) {
+                                // bottom out at unique expression.
+                                // The existence of a unique expression doesn't change the purity of an expression.
+                                // That is, even if the wrapped expression is impure, the wrapper protects the rest of the expression.
+                                visit_children = false;
+                                return;
+                        }
+                }
+        };
+
+        bool detectImpurity( const Expression * expr, bool ignoreUnique ) {
+                PassVisitor<ImpurityDetector_old> detector( ignoreUnique );
+                expr->accept( detector );
+                return detector.pass.maybeImpure;
+        }
+
         /// Determines if impurity (read: side-effects) may exist in a piece of code. Currently gives
         /// a very crude approximation, wherein any function call expression means the code may be
         /// impure.
     struct ImpurityDetector : public ast::WithShortCircuiting {
-                bool maybeImpure = false;
+                bool result = false;
 
                 void previsit( ast::ApplicationExpr const * appExpr ) {
@@ -36 +86 @@
                                 }
                         }
-                        maybeImpure = true; visit_children = false;
+                        result = true; visit_children = false;
                 }
                 void previsit( ast::UntypedExpr const * ) {
-                        maybeImpure = true; visit_children = false;
+                        result = true; visit_children = false;
                 }
         };
+
         struct ImpurityDetectorIgnoreUnique : public ImpurityDetector {
                 using ImpurityDetector::previsit;
@@ -48 +99 @@
                 }
         };
-
-        template<typename Detector>
-        bool detectImpurity( const ast::Expr * expr ) {
-                ast::Pass<Detector> detector;
-                expr->accept( detector );
-                return detector.core.maybeImpure;
-        }
 } // namespace
 
 bool maybeImpure( const ast::Expr * expr ) {
-        return detectImpurity<ImpurityDetector>( expr );
+        return ast::Pass<ImpurityDetector>::read( expr );
 }
 
 bool maybeImpureIgnoreUnique( const ast::Expr * expr ) {
-        return detectImpurity<ImpurityDetectorIgnoreUnique>( expr );
+        return ast::Pass<ImpurityDetectorIgnoreUnique>::read( expr );
+}
+
+bool maybeImpure( const Expression * expr ) {
+        return detectImpurity( expr, false );
+}
+
+bool maybeImpureIgnoreUnique( const Expression * expr ) {
+        return detectImpurity( expr, true );
 }
 

src/Tuples/module.mk

@@ -10 +10 @@
 ## Author           : Richard C. Bilson
 ## Created On       : Mon Jun  1 17:49:17 2015
-## Last Modified By : Henry Xue
-## Last Modified On : Mon Aug 23 15:36:09 2021
-## Update Count     : 2
+## Last Modified By : Andrew Beach
+## Last Modified On : Mon May 17 15:00:00 2022
+## Update Count     : 3
 ###############################################################################
 
@@ -24 +24 @@
         Tuples/Tuples.h
 
+SRC += $(SRC_TUPLES)
 
-SRC += $(SRC_TUPLES)
 SRCDEMANGLE += $(SRC_TUPLES)

src/Validate/Autogen.cpp

@@ -402 +402 @@
         auto retval = srcParam();
         retval->name = "_ret";
+        // xxx - Adding this unused attribute can slience unused variable warning
+        // However, some code might not be compiled as expected
+        // Temporarily disabled
+        // retval->attributes.push_back(new ast::Attribute("unused"));
         return genProto( "?=?", { dstParam(), srcParam() }, { retval } );
 }

src/Validate/module.mk

@@ -10 +10 @@
 ## Author           : Rob Schluntz
 ## Created On       : Fri Jul 27 10:10:10 2018
-## Last Modified By : Rob Schluntz
-## Last Modified On : Fri Jul 27 10:10:26 2018
-## Update Count     : 2
+## Last Modified By : Andrew Beach
+## Last Modified On : Tue May 17 14:59:00 2022
+## Update Count     : 3
 ###############################################################################
 
 SRC_VALIDATE = \
+        Validate/FindSpecialDecls.cc \
+        Validate/FindSpecialDecls.h
+
+SRC += $(SRC_VALIDATE) \
         Validate/Autogen.cpp \
         Validate/Autogen.hpp \
@@ -22 +26 @@
         Validate/EliminateTypedef.cpp \
         Validate/EliminateTypedef.hpp \
+        Validate/FindSpecialDeclsNew.cpp \
         Validate/FixQualifiedTypes.cpp \
         Validate/FixQualifiedTypes.hpp \
@@ -38 +43 @@
         Validate/NoIdSymbolTable.hpp \
         Validate/ReturnCheck.cpp \
-        Validate/ReturnCheck.hpp \
-        Validate/FindSpecialDeclsNew.cpp \
-        Validate/FindSpecialDecls.cc \
-        Validate/FindSpecialDecls.h
+        Validate/ReturnCheck.hpp
 
-SRC += $(SRC_VALIDATE)
 SRCDEMANGLE += $(SRC_VALIDATE)

src/Virtual/module.mk

@@ -11 +11 @@
 ## Created On       : Tus Jul 25 10:18:00 2017
 ## Last Modified By : Andrew Beach
-## Last Modified On : Tus Jul 25 10:18:00 2017
-## Update Count     : 0
+## Last Modified On : Tus May 17 14:59:00 2022
+## Update Count     : 1
 ###############################################################################
 
-SRC += Virtual/ExpandCasts.cc Virtual/ExpandCasts.h \
-        Virtual/Tables.cc Virtual/Tables.h
-
-SRCDEMANGLE += Virtual/Tables.cc
+SRC += \
+        Virtual/ExpandCasts.cc \
+        Virtual/ExpandCasts.h \
+        Virtual/Tables.cc \
+        Virtual/Tables.h

src/main.cc

@@ -70 +70 @@
 #include "ResolvExpr/Resolver.h"            // for resolve
 #include "SymTab/Validate.h"                // for validate
+#include "SymTab/ValidateType.h"            // for linkReferenceToTypes
 #include "SynTree/LinkageSpec.h"            // for Spec, Cforall, Intrinsic
 #include "SynTree/Declaration.h"            // for Declaration