Changeset 4dc3b8c

Timestamp:

Nov 30, 2023, 6:14:20 PM (23 months ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

master

Children:

2f8d351

Parents:

7f2bfb7 (diff), c4570af3 (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/Expr.cpp (modified) (2 diffs)
• AST/Expr.hpp (modified) (5 diffs)
• CodeGen/CodeGenerator.cpp (moved) (moved from src/CodeGen/CodeGeneratorNew.cpp ) (2 diffs)
• CodeGen/CodeGenerator.hpp (moved) (moved from src/CodeGen/CodeGeneratorNew.hpp ) (1 diff)
• CodeGen/GenType.cc (modified) (1 diff)
• CodeGen/Generate.cc (modified) (1 diff)
• CodeGen/module.mk (modified) (1 diff)
• Concurrency/Keywords.cpp (moved) (moved from src/Concurrency/KeywordsNew.cpp ) (3 diffs)
• Concurrency/Waitfor.cpp (moved) (moved from src/Concurrency/WaitforNew.cpp ) (1 diff)
• Concurrency/module.mk (modified) (1 diff)
• ControlStruct/ExceptDecl.cpp (moved) (moved from src/ControlStruct/ExceptDeclNew.cpp ) (1 diff)
• ControlStruct/ExceptTranslate.cpp (moved) (moved from src/ControlStruct/ExceptTranslateNew.cpp ) (1 diff)
• ControlStruct/LabelGenerator.cpp (moved) (moved from src/ControlStruct/LabelGeneratorNew.cpp ) (2 diffs)
• ControlStruct/LabelGenerator.hpp (moved) (moved from src/ControlStruct/LabelGeneratorNew.hpp ) (2 diffs)
• ControlStruct/MultiLevelExit.cpp (modified) (1 diff)
• ControlStruct/module.mk (modified) (2 diffs)
• GenPoly/Box.cpp (moved) (moved from src/GenPoly/BoxNew.cpp ) (2 diffs)
• GenPoly/FindFunction.cc (modified) (1 diff)
• GenPoly/InstantiateGeneric.cpp (moved) (moved from src/GenPoly/InstantiateGenericNew.cpp ) (2 diffs)
• GenPoly/Lvalue.cpp (moved) (moved from src/GenPoly/LvalueNew.cpp ) (1 diff)
• GenPoly/ScrubTypeVars.cpp (moved) (moved from src/GenPoly/ScrubTyVars.cc ) (3 diffs)
• GenPoly/ScrubTypeVars.hpp (moved) (moved from src/GenPoly/ScrubTyVars.h ) (1 diff)
• GenPoly/Specialize.cpp (moved) (moved from src/GenPoly/SpecializeNew.cpp ) (1 diff)
• GenPoly/module.mk (modified) (1 diff)
• InitTweak/FixInit.cpp (moved) (moved from src/InitTweak/FixInitNew.cpp )
• InitTweak/module.mk (modified) (1 diff)
• MakeLibCfa.cpp (moved) (moved from src/MakeLibCfaNew.cpp ) (1 diff)
• Makefile.am (modified) (1 diff)
• ResolvExpr/CandidateFinder.cpp (modified) (19 diffs)
• ResolvExpr/CandidateFinder.hpp (modified) (2 diffs)
• ResolvExpr/CandidatePrinter.cpp (modified) (3 diffs)
• ResolvExpr/ResolveMode.hpp (moved) (moved from src/ResolvExpr/ResolvMode.h ) (2 diffs)
• ResolvExpr/Resolver.cc (modified) (5 diffs)
• ResolvExpr/module.mk (modified) (1 diff)
• Tuples/TupleAssignment.cc (modified) (3 diffs)
• Tuples/TupleExpansion.cc (deleted)
• Tuples/TupleExpansion.cpp (moved) (moved from src/Tuples/TupleExpansionNew.cpp ) (2 diffs)
• Tuples/module.mk (modified) (1 diff)
• Validate/FindSpecialDecls.cpp (moved) (moved from src/Validate/FindSpecialDeclsNew.cpp ) (1 diff)
• Validate/FixReturnTypes.cpp (modified) (1 diff)
• Validate/LinkInstanceTypes.cpp (moved) (moved from src/Validate/LinkReferenceToTypes.cpp ) (3 diffs)
• Validate/LinkInstanceTypes.hpp (moved) (moved from src/Validate/LinkReferenceToTypes.hpp ) (2 diffs)
• Validate/module.mk (modified) (2 diffs)
• main.cc (modified) (2 diffs)

src/AST/Expr.cpp

@@ -222 +222 @@
 }
 
-MemberExpr::MemberExpr( const CodeLocation & loc, const DeclWithType * mem, const Expr * agg,
-    MemberExpr::NoOpConstruction overloadSelector )
-: Expr( loc ), member( mem ), aggregate( agg ) {
-        assert( member );
-        assert( aggregate );
-        assert( aggregate->result );
-        (void) overloadSelector;
-}
-
 bool MemberExpr::get_lvalue() const {
         // This is actually wrong by C, but it works with our current set-up.
@@ -388 +379 @@
         stmts.emplace_back( new ExprStmt{ loc, tupleExpr } );
         stmtExpr = new StmtExpr{ loc, new CompoundStmt{ loc, std::move(stmts) } };
-}
-
-TupleAssignExpr::TupleAssignExpr(
-        const CodeLocation & loc, const Type * result, const StmtExpr * s )
-: Expr( loc, result ), stmtExpr() {
-        stmtExpr = s;
 }
 

src/AST/Expr.hpp

@@ -35 +35 @@
         template<typename node_t> friend node_t * shallowCopy(const node_t * node);
 
-
-class ConverterOldToNew;
-class ConverterNewToOld;
-
 namespace ast {
 
@@ -439 +435 @@
         MemberExpr * clone() const override { return new MemberExpr{ *this }; }
         MUTATE_FRIEND
-
-        // Custructor overload meant only for AST conversion
-        enum NoOpConstruction { NoOpConstructionChosen };
-        MemberExpr( const CodeLocation & loc, const DeclWithType * mem, const Expr * agg,
-            NoOpConstruction overloadSelector );
-        friend class ::ConverterOldToNew;
-        friend class ::ConverterNewToOld;
 };
 
@@ -458 +447 @@
         ConstantExpr(
                 const CodeLocation & loc, const Type * ty, const std::string & r,
-                        std::optional<unsigned long long> i )
-        : Expr( loc, ty ), rep( r ), ival( i ), underlyer(ty) {}
+                        const std::optional<unsigned long long> & i )
+        : Expr( loc, ty ), rep( r ), ival( i ) {}
 
         /// Gets the integer value of this constant, if one is appropriate to its type.
@@ -483 +472 @@
 
         std::optional<unsigned long long> ival;
-
-        // Intended only for legacy support of roundtripping the old AST.
-        // Captures the very-locally inferred type, before the resolver modifies the type of this ConstantExpression.
-        // In the old AST it's constExpr->constant.type
-        ptr<Type> underlyer;
-        friend class ::ConverterOldToNew;
-        friend class ::ConverterNewToOld;
 };
 
@@ -779 +761 @@
         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
 
-        friend class ::ConverterOldToNew;
-
 private:
         TupleAssignExpr * clone() const override { return new TupleAssignExpr{ *this }; }
-    TupleAssignExpr( const CodeLocation & loc, const Type * result, const StmtExpr * s );
-
         MUTATE_FRIEND
 };

src/CodeGen/CodeGenerator.cpp

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// CodeGeneratorNew.cpp --
+// CodeGenerator.cpp --
 //
 // Author           : Andrew Beach
@@ -14 +14 @@
 //
 
-#include "CodeGeneratorNew.hpp"
+#include "CodeGenerator.hpp"
 
 #include "AST/Print.hpp"

src/CodeGen/CodeGenerator.hpp

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// CodeGeneratorNew.hpp --
+// CodeGenerator.hpp --
 //
 // Author           : Andrew Beach

src/CodeGen/GenType.cc

@@ -21 +21 @@
 #include "AST/Print.hpp"          // for print
 #include "AST/Vector.hpp"         // for vector
-#include "CodeGeneratorNew.hpp"   // for CodeGenerator
+#include "CodeGenerator.hpp"      // for CodeGenerator
 #include "Common/UniqueName.h"    // for UniqueName
 

src/CodeGen/Generate.cc

@@ -19 +19 @@
 #include <string>                    // for operator<<
 
-#include "CodeGeneratorNew.hpp"      // for CodeGenerator, doSemicolon, ...
+#include "CodeGenerator.hpp"         // for CodeGenerator, doSemicolon, ...
 #include "GenType.h"                 // for genPrettyType
 

src/CodeGen/module.mk

@@ -16 +16 @@
 
 SRC_CODEGEN = \
-        CodeGen/CodeGeneratorNew.cpp \
-        CodeGen/CodeGeneratorNew.hpp \
+        CodeGen/CodeGenerator.cpp \
+        CodeGen/CodeGenerator.hpp \
         CodeGen/GenType.cc \
         CodeGen/GenType.h \

src/Concurrency/Keywords.cpp

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// KeywordsNew.cpp -- Implement concurrency constructs from their keywords.
+// Keywords.cpp -- Implement concurrency constructs from their keywords.
 //
 // Author           : Andrew Beach
@@ -14 +14 @@
 //
 
+#include "Concurrency/Keywords.h"
+
 #include <iostream>
-
-#include "Concurrency/Keywords.h"
 
 #include "AST/Copy.hpp"
@@ -30 +30 @@
 #include "Common/utility.h"
 #include "Common/UniqueName.h"
-#include "ControlStruct/LabelGeneratorNew.hpp"
+#include "ControlStruct/LabelGenerator.hpp"
 #include "InitTweak/InitTweak.h"
 #include "Virtual/Tables.h"

src/Concurrency/Waitfor.cpp

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// WaitforNew.cpp -- Expand waitfor clauses into code.
+// Waitfor.cpp -- Expand waitfor clauses into code.
 //
 // Author           : Andrew Beach

src/Concurrency/module.mk

@@ -20 +20 @@
         Concurrency/Corun.cpp \
         Concurrency/Corun.hpp \
-        Concurrency/KeywordsNew.cpp \
+        Concurrency/Keywords.cpp \
         Concurrency/Keywords.h \
-        Concurrency/WaitforNew.cpp \
+        Concurrency/Waitfor.cpp \
         Concurrency/Waitfor.h \
         Concurrency/Waituntil.cpp \

src/ControlStruct/ExceptDecl.cpp

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// ExceptDeclNew.cpp --
+// ExceptDecl.cpp --
 //
 // Author           : Andrew Beach

src/ControlStruct/ExceptTranslate.cpp

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// ExceptTranslateNew.cpp -- Conversion of exception control flow structures.
+// ExceptTranslate.cpp -- Conversion of exception control flow structures.
 //
 // Author           : Andrew Beach

src/ControlStruct/LabelGenerator.cpp

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// LabelGeneratorNew.cpp --
+// LabelGenerator.cpp --
 //
 // Author           : Peter A. Buhr
@@ -14 +14 @@
 //
 
-#include "LabelGeneratorNew.hpp"
+#include "LabelGenerator.hpp"
 
 #include "AST/Attribute.hpp"

src/ControlStruct/LabelGenerator.hpp

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// LabelGenerator.h --
+// LabelGenerator.hpp --
 //
 // Author           : Rodolfo G. Esteves
@@ -26 +26 @@
 
 namespace ControlStruct {
-        ast::Label newLabel( const std::string &, const ast::Stmt * );
-        ast::Label newLabel( const std::string &, const CodeLocation & );
+
+ast::Label newLabel( const std::string &, const ast::Stmt * );
+ast::Label newLabel( const std::string &, const CodeLocation & );
+
 } // namespace ControlStruct
 

src/ControlStruct/MultiLevelExit.cpp

@@ -16 +16 @@
 #include "MultiLevelExit.hpp"
 
+#include <set>
+
 #include "AST/Pass.hpp"
 #include "AST/Stmt.hpp"
-#include "LabelGeneratorNew.hpp"
-
-#include <set>
+#include "LabelGenerator.hpp"
+
 using namespace std;
 using namespace ast;

src/ControlStruct/module.mk

@@ -16 +16 @@
 
 SRC += \
-        ControlStruct/ExceptDeclNew.cpp \
+        ControlStruct/ExceptDecl.cpp \
         ControlStruct/ExceptDecl.h \
-        ControlStruct/ExceptTranslateNew.cpp \
+        ControlStruct/ExceptTranslate.cpp \
         ControlStruct/ExceptTranslate.h \
         ControlStruct/FixLabels.cpp \
@@ -24 +24 @@
         ControlStruct/HoistControlDecls.cpp \
         ControlStruct/HoistControlDecls.hpp \
-        ControlStruct/LabelGeneratorNew.cpp \
-        ControlStruct/LabelGeneratorNew.hpp \
+        ControlStruct/LabelGenerator.cpp \
+        ControlStruct/LabelGenerator.hpp \
         ControlStruct/MultiLevelExit.cpp \
         ControlStruct/MultiLevelExit.hpp

src/GenPoly/Box.cpp

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// BoxNew.cpp -- Implement polymorphic function calls and types.
+// Box.cpp -- Implement polymorphic function calls and types.
 //
 // Author           : Andrew Beach
@@ -32 +32 @@
 #include "GenPoly/Lvalue.h"            // for generalizedLvalue
 #include "GenPoly/ScopedSet.h"         // for ScopedSet
-#include "GenPoly/ScrubTyVars.h"       // for scrubTypeVars, scrubAllTypeVars
+#include "GenPoly/ScrubTypeVars.hpp"   // for scrubTypeVars, scrubAllTypeVars
 #include "ResolvExpr/Unify.h"          // for typesCompatible
 #include "SymTab/Mangler.h"            // for mangle, mangleType

src/GenPoly/FindFunction.cc

@@ -22 +22 @@
 #include "GenPoly/ErasableScopedMap.h"  // for ErasableScopedMap<>::iterator
 #include "GenPoly/GenPoly.h"            // for TyVarMap
-#include "ScrubTyVars.h"                // for ScrubTyVars
+#include "ScrubTypeVars.hpp"            // for scrubTypeVars
 
 namespace GenPoly {

src/GenPoly/InstantiateGeneric.cpp

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// InstantiateGenericNew.cpp -- Create concrete instances of generic types.
+// InstantiateGeneric.cpp -- Create concrete instances of generic types.
 //
 // Author           : Andrew Beach
@@ -31 +31 @@
 #include "Common/UniqueName.h"         // for UniqueName
 #include "GenPoly/GenPoly.h"           // for isPolyType, typesPolyCompatible
-#include "GenPoly/ScrubTyVars.h"       // for scrubAll
+#include "GenPoly/ScrubTypeVars.hpp"   // for scrubAllTypeVars
 #include "ResolvExpr/AdjustExprType.hpp"  // for adjustExprType
 #include "ResolvExpr/Unify.h"          // for typesCompatible

src/GenPoly/Lvalue.cpp

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// LvalueNew.cpp -- Clean up lvalues and remove references.
+// Lvalue.cpp -- Clean up lvalues and remove references.
 //
 // Author           : Andrew Beach

src/GenPoly/ScrubTypeVars.cpp

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// ScrubTyVars.cc -- Remove polymorphic types.
+// ScrubTypeVars.cpp -- Remove polymorphic types.
 //
 // Author           : Richard C. Bilson
@@ -14 +14 @@
 //
 
+#include "ScrubTypeVars.hpp"
+
 #include <utility>                      // for pair
 
@@ -19 +21 @@
 #include "GenPoly.h"                    // for mangleType, TyVarMap, alignof...
 #include "GenPoly/ErasableScopedMap.h"  // for ErasableScopedMap<>::const_it...
-#include "ScrubTyVars.h"
 #include "SymTab/Mangler.h"             // for mangleType
 

src/GenPoly/ScrubTypeVars.hpp

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// ScrubTyVars.h -- Remove polymorphic types.
+// ScrubTypeVars.hpp -- Remove polymorphic types.
 //
 // Author           : Richard C. Bilson

src/GenPoly/Specialize.cpp

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// SpecializeNew.cpp -- Generate thunks to specialize polymorphic functions.
+// Specialize.cpp -- Generate thunks to specialize polymorphic functions.
 //
 // Author           : Andrew Beach

src/GenPoly/module.mk

@@ -22 +22 @@
 
 SRC += $(SRC_GENPOLY) \
-        GenPoly/BoxNew.cpp \
+        GenPoly/Box.cpp \
         GenPoly/Box.h \
         GenPoly/ErasableScopedMap.h \
         GenPoly/FindFunction.cc \
         GenPoly/FindFunction.h \
-        GenPoly/InstantiateGenericNew.cpp \
+        GenPoly/InstantiateGeneric.cpp \
         GenPoly/InstantiateGeneric.h \
-        GenPoly/LvalueNew.cpp \
+        GenPoly/Lvalue.cpp \
         GenPoly/ScopedSet.h \
-        GenPoly/ScrubTyVars.cc \
-        GenPoly/ScrubTyVars.h \
-        GenPoly/SpecializeNew.cpp \
+        GenPoly/ScrubTypeVars.cpp \
+        GenPoly/ScrubTypeVars.hpp \
+        GenPoly/Specialize.cpp \
         GenPoly/Specialize.h
 

src/InitTweak/module.mk

@@ -24 +24 @@
         InitTweak/FixGlobalInit.cc \
         InitTweak/FixGlobalInit.h \
-        InitTweak/FixInit.h \
-        InitTweak/FixInitNew.cpp
+        InitTweak/FixInit.cpp \
+        InitTweak/FixInit.h
 
 SRCDEMANGLE += $(SRC_INITTWEAK)

src/MakeLibCfa.cpp

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// MakeLibCfaNew.cpp --
+// MakeLibCfa.cpp --
 //
 // Author           : Henry Xue

src/Makefile.am

@@ -22 +22 @@
         CompilationState.cc \
         CompilationState.h \
-        MakeLibCfaNew.cpp \
+        MakeLibCfa.cpp \
         MakeLibCfa.h
 

src/ResolvExpr/CandidateFinder.cpp

@@ -105 +105 @@
 
                         // CandidateFinder finder{ symtab, env };
-                        // finder.find( arg, ResolvMode::withAdjustment() );
+                        // finder.find( arg, ResolveMode::withAdjustment() );
                         // assertf( finder.candidates.size() > 0,
                         //      "Somehow castable expression failed to find alternatives." );
@@ -974 +974 @@
                 // xxx - is it possible that handleTupleAssignment and main finder both produce candidates?
                 // this means there exists ctor/assign functions with a tuple as first parameter.
-                ResolvMode mode = {
+                ResolveMode mode = {
                         true, // adjust
                         !untypedExpr->func.as<ast::NameExpr>(), // prune if not calling by name
@@ -989 +989 @@
                 CandidateFinder opFinder( context, tenv );
                 // okay if there aren't any function operations
-                opFinder.find( opExpr, ResolvMode::withoutFailFast() );
+                opFinder.find( opExpr, ResolveMode::withoutFailFast() );
                 PRINT(
                         std::cerr << "known function ops:" << std::endl;
@@ -1175 +1175 @@
                 if ( castExpr->kind == ast::CastExpr::Return ) {
                         finder.strictMode = true;
-                        finder.find( castExpr->arg, ResolvMode::withAdjustment() );
+                        finder.find( castExpr->arg, ResolveMode::withAdjustment() );
 
                         // return casts are eliminated (merely selecting an overload, no actual operation)
                         candidates = std::move(finder.candidates);
                 }
-                finder.find( castExpr->arg, ResolvMode::withAdjustment() );
+                finder.find( castExpr->arg, ResolveMode::withAdjustment() );
 
                 if ( !finder.candidates.empty() ) reason.code = NoMatch;
@@ -1251 +1251 @@
                 CandidateFinder finder( context, tenv );
                 // don't prune here, all alternatives guaranteed to have same type
-                finder.find( castExpr->arg, ResolvMode::withoutPrune() );
+                finder.find( castExpr->arg, ResolveMode::withoutPrune() );
                 for ( CandidateRef & r : finder.candidates ) {
                         addCandidate(
@@ -1298 +1298 @@
 
                         // don't prune here, since it's guaranteed all alternatives will have the same type
-                        finder.find( tech1.get(), ResolvMode::withoutPrune() );
+                        finder.find( tech1.get(), ResolveMode::withoutPrune() );
                         pick_alternatives(finder.candidates, false);
 
@@ -1307 +1307 @@
                 std::unique_ptr<const ast::Expr> fallback { ast::UntypedExpr::createDeref(loc,  new ast::UntypedExpr(loc, new ast::NameExpr(loc, castExpr->concrete_target.getter), { castExpr->arg })) };
                 // don't prune here, since it's guaranteed all alternatives will have the same type
-                finder.find( fallback.get(), ResolvMode::withoutPrune() );
+                finder.find( fallback.get(), ResolveMode::withoutPrune() );
 
                 pick_alternatives(finder.candidates, true);
@@ -1316 +1316 @@
         void Finder::postvisit( const ast::UntypedMemberExpr * memberExpr ) {
                 CandidateFinder aggFinder( context, tenv );
-                aggFinder.find( memberExpr->aggregate, ResolvMode::withAdjustment() );
+                aggFinder.find( memberExpr->aggregate, ResolveMode::withAdjustment() );
                 for ( CandidateRef & agg : aggFinder.candidates ) {
                         // it's okay for the aggregate expression to have reference type -- cast it to the
@@ -1475 +1475 @@
         void Finder::postvisit( const ast::LogicalExpr * logicalExpr ) {
                 CandidateFinder finder1( context, tenv );
-                finder1.find( logicalExpr->arg1, ResolvMode::withAdjustment() );
+                finder1.find( logicalExpr->arg1, ResolveMode::withAdjustment() );
                 if ( finder1.candidates.empty() ) return;
 
                 CandidateFinder finder2( context, tenv );
-                finder2.find( logicalExpr->arg2, ResolvMode::withAdjustment() );
+                finder2.find( logicalExpr->arg2, ResolveMode::withAdjustment() );
                 if ( finder2.candidates.empty() ) return;
 
@@ -1505 +1505 @@
                 // candidates for condition
                 CandidateFinder finder1( context, tenv );
-                finder1.find( conditionalExpr->arg1, ResolvMode::withAdjustment() );
+                finder1.find( conditionalExpr->arg1, ResolveMode::withAdjustment() );
                 if ( finder1.candidates.empty() ) return;
 
@@ -1511 +1511 @@
                 CandidateFinder finder2( context, tenv );
                 finder2.allowVoid = true;
-                finder2.find( conditionalExpr->arg2, ResolvMode::withAdjustment() );
+                finder2.find( conditionalExpr->arg2, ResolveMode::withAdjustment() );
                 if ( finder2.candidates.empty() ) return;
 
@@ -1517 +1517 @@
                 CandidateFinder finder3( context, tenv );
                 finder3.allowVoid = true;
-                finder3.find( conditionalExpr->arg3, ResolvMode::withAdjustment() );
+                finder3.find( conditionalExpr->arg3, ResolveMode::withAdjustment() );
                 if ( finder3.candidates.empty() ) return;
 
@@ -1570 +1570 @@
 
                 CandidateFinder finder2( context, env );
-                finder2.find( commaExpr->arg2, ResolvMode::withAdjustment() );
+                finder2.find( commaExpr->arg2, ResolveMode::withAdjustment() );
 
                 for ( const CandidateRef & r2 : finder2.candidates ) {
@@ -1584 +1584 @@
                 CandidateFinder finder( context, tenv );
                 finder.allowVoid = true;
-                finder.find( ctorExpr->callExpr, ResolvMode::withoutPrune() );
+                finder.find( ctorExpr->callExpr, ResolveMode::withoutPrune() );
                 for ( CandidateRef & r : finder.candidates ) {
                         addCandidate( *r, new ast::ConstructorExpr{ ctorExpr->location, r->expr } );
@@ -1593 +1593 @@
                 // resolve low and high, accept candidates where low and high types unify
                 CandidateFinder finder1( context, tenv );
-                finder1.find( rangeExpr->low, ResolvMode::withAdjustment() );
+                finder1.find( rangeExpr->low, ResolveMode::withAdjustment() );
                 if ( finder1.candidates.empty() ) return;
 
                 CandidateFinder finder2( context, tenv );
-                finder2.find( rangeExpr->high, ResolvMode::withAdjustment() );
+                finder2.find( rangeExpr->high, ResolveMode::withAdjustment() );
                 if ( finder2.candidates.empty() ) return;
 
@@ -1673 +1673 @@
         void Finder::postvisit( const ast::UniqueExpr * unqExpr ) {
                 CandidateFinder finder( context, tenv );
-                finder.find( unqExpr->expr, ResolvMode::withAdjustment() );
+                finder.find( unqExpr->expr, ResolveMode::withAdjustment() );
                 for ( CandidateRef & r : finder.candidates ) {
                         // ensure that the the id is passed on so that the expressions are "linked"
@@ -1699 +1699 @@
                         // only open for the duration of resolving the UntypedExpr.
                         CandidateFinder finder( context, tenv, toType );
-                        finder.find( initExpr->expr, ResolvMode::withAdjustment() );
+                        finder.find( initExpr->expr, ResolveMode::withAdjustment() );
 
                         Cost minExprCost = Cost::infinity;
@@ -1889 +1889 @@
 }
 
-void CandidateFinder::find( const ast::Expr * expr, ResolvMode mode ) {
+void CandidateFinder::find( const ast::Expr * expr, ResolveMode mode ) {
         // Find alternatives for expression
         ast::Pass<Finder> finder{ *this };
@@ -2004 +2004 @@
         for ( const auto & x : xs ) {
                 out.emplace_back( context, env );
-                out.back().find( x, ResolvMode::withAdjustment() );
+                out.back().find( x, ResolveMode::withAdjustment() );
 
                 PRINT(

src/ResolvExpr/CandidateFinder.hpp

@@ -17 +17 @@
 
 #include "Candidate.hpp"
-#include "ResolvMode.h"
+#include "ResolveMode.hpp"
 #include "AST/Fwd.hpp"
 #include "AST/Node.hpp"
@@ -43 +43 @@
 
         /// Fill candidates with feasible resolutions for `expr`
-        void find( const ast::Expr * expr, ResolvMode mode = {} );
+        void find( const ast::Expr * expr, ResolveMode mode = {} );
         bool pruneCandidates( CandidateList & candidates, CandidateList & out, std::vector<std::string> & errors );
 

src/ResolvExpr/CandidatePrinter.cpp

@@ -16 +16 @@
 #include "CandidatePrinter.hpp"
 
+#include <iostream>
+
 #include "AST/Expr.hpp"
 #include "AST/Pass.hpp"
@@ -23 +25 @@
 #include "ResolvExpr/CandidateFinder.hpp"
 #include "ResolvExpr/Resolver.h"
-
-#include <iostream>
 
 namespace ResolvExpr {
@@ -39 +39 @@
                 ast::TypeEnvironment env;
                 CandidateFinder finder( { symtab, transUnit().global }, env );
-                finder.find( stmt->expr, ResolvMode::withAdjustment() );
+                finder.find( stmt->expr, ResolveMode::withAdjustment() );
                 int count = 1;
                 os << "There are " << finder.candidates.size() << " candidates\n";

src/ResolvExpr/ResolveMode.hpp

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// ResolvMode.h --
+// ResolveMode.hpp --
 //
 // Author           : Aaron B. Moss
@@ -19 +19 @@
 
 /// Flag set for resolution
-struct ResolvMode {
+struct ResolveMode {
         const bool adjust;                       ///< Adjust array and function types to pointer types? [false]
         const bool prune;            ///< Prune alternatives to min-cost per return type? [true]
         const bool failFast;         ///< Fail on no resulting alternatives? [true]
 
-        constexpr ResolvMode(bool a, bool p, bool ff)
+        constexpr ResolveMode(bool a, bool p, bool ff)
         : adjust(a), prune(p), failFast(ff) {}
 
         /// Default settings
-        constexpr ResolvMode() : adjust(false), prune(true), failFast(true) {}
+        constexpr ResolveMode() : adjust(false), prune(true), failFast(true) {}
 
         /// With adjust flag set; turns array and function types into equivalent pointers
-        static constexpr ResolvMode withAdjustment() { return { true, true, true }; }
+        static constexpr ResolveMode withAdjustment() { return { true, true, true }; }
 
         /// With adjust flag set but prune unset; pruning ensures there is at least one alternative
         /// per result type
-        static constexpr ResolvMode withoutPrune() { return { true, false, true }; }
+        static constexpr ResolveMode withoutPrune() { return { true, false, true }; }
 
         /// With adjust and prune flags set but failFast unset; failFast ensures there is at least
         /// one resulting alternative
-        static constexpr ResolvMode withoutFailFast() { return { true, true, false }; }
+        static constexpr ResolveMode withoutFailFast() { return { true, true, false }; }
 
         /// The same mode, but with satisfyAssns turned on; for top-level calls
-        ResolvMode atTopLevel() const { return { adjust, true, failFast }; }
+        ResolveMode atTopLevel() const { return { adjust, true, failFast }; }
 };
 

src/ResolvExpr/Resolver.cc

@@ -25 +25 @@
 #include "Resolver.h"
 #include "ResolveTypeof.h"
-#include "ResolvMode.h"                  // for ResolvMode
+#include "ResolveMode.hpp"               // for ResolveMode
 #include "typeops.h"                     // for extractResultType
 #include "Unify.h"                       // for unify
@@ -123 +123 @@
                 CandidateRef findUnfinishedKindExpression(
                         const ast::Expr * untyped, const ResolveContext & context, const std::string & kind,
-                        std::function<bool(const Candidate &)> pred = anyCandidate, ResolvMode mode = {}
+                        std::function<bool(const Candidate &)> pred = anyCandidate, ResolveMode mode = {}
                 ) {
                         if ( ! untyped ) return nullptr;
@@ -263 +263 @@
                 ast::ptr< ast::CastExpr > untyped = new ast::CastExpr{ expr };
                 CandidateRef choice = findUnfinishedKindExpression(
-                        untyped, context, "", anyCandidate, ResolvMode::withAdjustment() );
+                        untyped, context, "", anyCandidate, ResolveMode::withAdjustment() );
 
                 // a cast expression has either 0 or 1 interpretations (by language rules);
@@ -292 +292 @@
                         const ast::Expr * untyped, const ResolveContext & context,
                         std::function<bool(const Candidate &)> pred = anyCandidate,
-                        const std::string & kind = "", ResolvMode mode = {}
+                        const std::string & kind = "", ResolveMode mode = {}
                 ) {
                         if ( ! untyped ) return {};
@@ -860 +860 @@
 
                         // Find all candidates for a function in canonical form
-                        funcFinder.find( clause.target, ResolvMode::withAdjustment() );
+                        funcFinder.find( clause.target, ResolveMode::withAdjustment() );
 
                         if ( funcFinder.candidates.empty() ) {

src/ResolvExpr/module.mk

@@ -47 +47 @@
       ResolvExpr/ResolveTypeof.cc \
       ResolvExpr/ResolveTypeof.h \
-      ResolvExpr/ResolvMode.h \
+      ResolvExpr/ResolveMode.hpp \
       ResolvExpr/SatisfyAssertions.cpp \
       ResolvExpr/SatisfyAssertions.hpp \

src/Tuples/TupleAssignment.cc

@@ -13 +13 @@
 // Update Count     : 10
 //
+
+#include "Tuples.h"
 
 #include <algorithm>                       // for transform
@@ -224 +226 @@
                                 // by the cast type as needed, and transfer the resulting environment.
                                 ResolvExpr::CandidateFinder finder( spotter.crntFinder.context, env );
-                                finder.find( rhsCand->expr, ResolvExpr::ResolvMode::withAdjustment() );
+                                finder.find( rhsCand->expr, ResolvExpr::ResolveMode::withAdjustment() );
                                 assert( 1 == finder.candidates.size() );
                                 env = std::move( finder.candidates.front()->env );
@@ -345 +347 @@
 
                         try {
-                                finder.find( expr, ResolvExpr::ResolvMode::withAdjustment() );
+                                finder.find( expr, ResolvExpr::ResolveMode::withAdjustment() );
                         } catch (...) {
                                 // No match is not failure, just that this tuple assignment is invalid.

src/Tuples/TupleExpansion.cpp

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// TupleExpansionNew.cpp --
+// TupleExpansion.cpp --
 //
 // Author           : Henry Xue
@@ -294 +294 @@
 }
 
+const ast::Type * makeTupleType( const std::vector<ast::ptr<ast::Expr>> & exprs ) {
+        // If there are no expressions, the answer is set, otherwise go through a loop.
+        if ( exprs.empty() ) return new ast::TupleType( {} );
+
+        std::vector<ast::ptr<ast::Type>> types;
+        ast::CV::Qualifiers quals(
+                ast::CV::Const | ast::CV::Volatile | ast::CV::Restrict |
+                ast::CV::Atomic | ast::CV::Mutex );
+
+        for ( const ast::Expr * expr : exprs ) {
+                assert( expr->result );
+                // If the type of any expr is void, the type of the entire tuple is void.
+                if ( expr->result->isVoid() ) return new ast::VoidType();
+
+                // Qualifiers on the tuple type are the qualifiers that exist on all components.
+                quals &= expr->result->qualifiers;
+
+                types.emplace_back( expr->result );
+        }
+
+        return new ast::TupleType( std::move( types ), quals );
+}
+
+const ast::TypeInstType * isTtype( const ast::Type * type ) {
+        if ( const ast::TypeInstType * inst = dynamic_cast< const ast::TypeInstType * >( type ) ) {
+                if ( inst->base && inst->base->kind == ast::TypeDecl::Ttype ) {
+                        return inst;
+                }
+        }
+        return nullptr;
+}
+
 } // namespace Tuples
+

src/Tuples/module.mk

@@ -19 +19 @@
         Tuples/Explode.h \
         Tuples/TupleAssignment.cc \
-        Tuples/TupleExpansion.cc \
-        Tuples/TupleExpansionNew.cpp \
+        Tuples/TupleExpansion.cpp \
         Tuples/Tuples.cc \
         Tuples/Tuples.h

src/Validate/FindSpecialDecls.cpp

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// FindSpecialDeclsNew.cpp -- Find special declarations used in the compiler.
+// FindSpecialDecls.cpp -- Find special declarations used in the compiler.
 //
 // Author           : Andrew Beach

src/Validate/FixReturnTypes.cpp

@@ -19 +19 @@
 #include "AST/Pass.hpp"
 #include "AST/Type.hpp"
-#include "CodeGen/CodeGeneratorNew.hpp"
+#include "CodeGen/CodeGenerator.hpp"
 #include "ResolvExpr/Unify.h"
-
-namespace ast {
-    class TranslationUnit;
-}
 
 namespace Validate {

src/Validate/LinkInstanceTypes.cpp

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// LinkReferenceToTypes.cpp -- Connect instance types to declarations.
+// LinkInstanceTypes.cpp -- Connect instance types to declarations.
 //
 // Author           : Andrew Beach
@@ -14 +14 @@
 //
 
-#include "Validate/LinkReferenceToTypes.hpp"
+#include "Validate/LinkInstanceTypes.hpp"
 
 #include "AST/Pass.hpp"
@@ -331 +331 @@
 } // namespace
 
-void linkReferenceToTypes( ast::TranslationUnit & translationUnit ) {
+void linkInstanceTypes( ast::TranslationUnit & translationUnit ) {
         ast::Pass<LinkTypesCore>::run( translationUnit );
 }

src/Validate/LinkInstanceTypes.hpp

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// LinkReferenceToTypes.hpp -- Connect instance types to declarations.
+// LinkInstanceTypes.hpp -- Connect instance types to declarations.
 //
 // Author           : Andrew Beach
@@ -25 +25 @@
 /// adjustments, such as setting the sized flag.
 /// Because of the sized flag, it must happen before auto-gen.
-void linkReferenceToTypes( ast::TranslationUnit & translationUnit );
+void linkInstanceTypes( ast::TranslationUnit & translationUnit );
 
 }

src/Validate/module.mk

@@ -27 +27 @@
         Validate/EnumAndPointerDecay.cpp \
         Validate/EnumAndPointerDecay.hpp \
-        Validate/FindSpecialDeclsNew.cpp \
+        Validate/FindSpecialDecls.cpp \
         Validate/FixQualifiedTypes.cpp \
         Validate/FixQualifiedTypes.hpp \
@@ -44 +44 @@
         Validate/LabelAddressFixer.cpp \
         Validate/LabelAddressFixer.hpp \
-        Validate/LinkReferenceToTypes.cpp \
-        Validate/LinkReferenceToTypes.hpp \
+        Validate/LinkInstanceTypes.cpp \
+        Validate/LinkInstanceTypes.hpp \
         Validate/NoIdSymbolTable.hpp \
         Validate/ReplaceTypedef.cpp \

src/main.cc

@@ -78 +78 @@
 #include "Validate/InitializerLength.hpp"   // for setLengthFromInitializer
 #include "Validate/LabelAddressFixer.hpp"   // for fixLabelAddresses
-#include "Validate/LinkReferenceToTypes.hpp" // for linkReferenceToTypes
+#include "Validate/LinkInstanceTypes.hpp"   // for linkInstanceTypes
 #include "Validate/ReplaceTypedef.hpp"      // for replaceTypedef
 #include "Validate/ReturnCheck.hpp"         // for checkReturnStatements
 #include "Validate/VerifyCtorDtorAssign.hpp" // for verifyCtorDtorAssign
 #include "Virtual/ExpandCasts.h"            // for expandCasts
-#include "Virtual/VirtualDtor.hpp"           // for implementVirtDtors
+#include "Virtual/VirtualDtor.hpp"          // for implementVirtDtors
 
 using namespace std;
@@ -318 +318 @@
                 PASS( "Enum and Pointer Decay", Validate::decayEnumsAndPointers, transUnit );
 
-                PASS( "Link Reference To Types", Validate::linkReferenceToTypes, transUnit );
+                PASS( "Link Instance Types", Validate::linkInstanceTypes, transUnit );
 
                 PASS( "Forall Pointer Decay", Validate::decayForallPointers, transUnit );