Changes in / [8d70648:d88f8b3b]

Location:

src

Files:

• AST/Convert.cpp (modified) (2 diffs)
• AST/Decl.cpp (modified) (2 diffs)
• AST/Decl.hpp (modified) (4 diffs)
• AST/Expr.cpp (modified) (4 diffs)
• AST/Node.hpp (modified) (2 diffs)
• AST/Pass.hpp (modified) (1 diff)
• AST/Pass.proto.hpp (modified) (1 diff)
• AST/Print.hpp (modified) (2 diffs)
• AST/SymbolTable.cpp (deleted)
• AST/SymbolTable.hpp (deleted)
• AST/Type.cpp (modified) (2 diffs)
• AST/Type.hpp (modified) (4 diffs)
• AST/TypeEnvironment.cpp (deleted)
• AST/TypeEnvironment.hpp (deleted)
• AST/module.mk (modified) (1 diff)
• AST/porting.md (modified) (2 diffs)
• GenPoly/GenPoly.cc (modified) (2 diffs)
• GenPoly/GenPoly.h (modified) (2 diffs)
• InitTweak/InitTweak.cc (modified) (1 diff)
• InitTweak/InitTweak.h (modified) (1 diff)
• Makefile.in (modified) (4 diffs)
• ResolvExpr/AlternativeFinder.cc (modified) (2 diffs)
• ResolvExpr/ResolveAssertions.cc (modified) (2 diffs)
• ResolvExpr/Resolver.cc (modified) (28 diffs)
• ResolvExpr/Resolver.h (modified) (3 diffs)
• ResolvExpr/Unify.cc (modified) (4 diffs)
• ResolvExpr/Unify.h (modified) (2 diffs)
• ResolvExpr/typeops.h (modified) (4 diffs)
• SymTab/Mangler.cc (modified) (1 diff)
• SymTab/Mangler.h (modified) (2 diffs)

src/AST/Convert.cpp

@@ -75 +75 @@
                 std::list< T * > acceptL( const U & container ) {
                         std::list< T * > ret;
-                        for ( auto ptr : container ) {
+                        for (auto ptr : container ) {
                                 ret.emplace_back( accept1( ptr ) );
                         }
@@ -1445 +1445 @@
                 };
                 cache.emplace( old, decl );
-                decl->withExprs = GET_ACCEPT_V(withExprs, Expr);
                 decl->stmts = GET_ACCEPT_1(statements, CompoundStmt);
                 decl->scopeLevel = old->scopeLevel;

src/AST/Decl.cpp

@@ -17 +17 @@
 
 #include <cassert>             // for assert, strict_dynamic_cast
-#include <iostream>
 #include <string>
 #include <unordered_map>
@@ -71 +70 @@
 }
 
-std::ostream & operator<< ( std::ostream & out, const TypeDecl::Data & data ) {
-        return out << data.kind << ", " << data.isComplete;
-}
-
 // --- EnumDecl
 

src/AST/Decl.hpp

@@ -16 +16 @@
 #pragma once
 
-#include <iosfwd>
 #include <string>              // for string, to_string
 #include <unordered_map>
@@ -122 +121 @@
         ptr<FunctionType> type;
         ptr<CompoundStmt> stmts;
-        std::vector< ptr<Expr> > withExprs;
+        std::list< ptr<Expr> > withExprs;
 
         FunctionDecl( const CodeLocation & loc, const std::string &name, FunctionType * type,
@@ -173 +172 @@
 
                 Data() : kind( (TypeVar::Kind)-1 ), isComplete( false ) {}
-                Data( const TypeDecl * d ) : kind( d->kind ), isComplete( d->sized ) {}
+                Data( TypeDecl* d ) : kind( d->kind ), isComplete( d->sized ) {}
                 Data( TypeVar::Kind k, bool c ) : kind( k ), isComplete( c ) {}
-                Data( const Data & d1, const Data & d2 )
+                Data( const Data& d1, const Data& d2 )
                 : kind( d1.kind ), isComplete( d1.isComplete || d2.isComplete ) {}
 
-                bool operator== ( const Data & o ) const {
+                bool operator== ( const Data& o ) const {
                         return kind == o.kind && isComplete == o.isComplete;
                 }
-                bool operator!= ( const Data & o ) const { return !(*this == o); }
+                bool operator!= ( const Data& o ) const { return !(*this == o); }
         };
 
@@ -201 +200 @@
         MUTATE_FRIEND
 };
-
-std::ostream & operator<< ( std::ostream &, const TypeDecl::Data & );
 
 /// C-style typedef `typedef Foo Bar`

src/AST/Expr.cpp

@@ -64 +64 @@
                         // references have been removed, in which case dereference returns an lvalue of the
                         // base type
-                        ret->result = base;
-                        add_lvalue( ret->result );
+                        ret->result.set_and_mutate( base )->set_lvalue( true );
                 }
         }
@@ -174 +173 @@
         assert( var );
         assert( var->get_type() );
-        result = var->get_type();
-        add_lvalue( result );
+        result.set_and_mutate( var->get_type() )->set_lvalue( true );
 }
 
@@ -308 +306 @@
 : Expr( loc ), init( i ) {
         assert( t && i );
-        result = t;
-        add_lvalue( result );
+        result.set_and_mutate( t )->set_lvalue( true );
 }
 
@@ -325 +322 @@
                 "index %d in expr %s", type->size(), index, toString( tuple ).c_str() );
         // like MemberExpr, TupleIndexExpr is always an lvalue
-        result = type->types[ index ];
-        add_lvalue( result );
+        result.set_and_mutate( type->types[ index ] )->set_lvalue( true );
 }
 

src/AST/Node.hpp

@@ -113 +113 @@
         }
 
-        ptr_base( ptr_base && o ) : node(o.node) { o.node = nullptr; }
+        ptr_base( ptr_base && o ) : node(o.node) {
+                if( node ) _inc(node);
+        }
 
         template< enum Node::ref_type o_ref_t >
@@ -137 +139 @@
 
         ptr_base & operator=( ptr_base && o ) {
-                if ( node == o.node ) return *this;
-                if ( node ) _dec(node);
-                node = o.node;
-                o.node = nullptr;
+                assign(o.node);
                 return *this;
         }

src/AST/Pass.hpp

@@ -179 +179 @@
 
         template<typename pass_type>
-        friend void accept_all( std::list< ptr<Decl> > & decls, Pass<pass_type>& visitor );
+        friend void acceptAll( std::list< ptr<Decl> > & decls, Pass<pass_type>& visitor );
 private:
 

src/AST/Pass.proto.hpp

@@ -312 +312 @@
                 INDEXER_FUNC1( addTrait  , const TraitDecl *     );
                 INDEXER_FUNC2( addWith   , const std::vector< ptr<Expr> > &, const Node * );
+                INDEXER_FUNC2( addWith   , const std::list  < ptr<Expr> > &, const Node * );
 
                 // A few extra functions have more complicated behaviour, they are hand written

src/AST/Print.hpp

@@ -17 +17 @@
 
 #include <iosfwd>
-#include <utility> // for forward
 
 #include "AST/Node.hpp"
@@ -29 +28 @@
 void print( std::ostream & os, const ast::Node * node, Indenter indent = {} );
 
-/// Wrap any standard format printer (matching above) with integer Indenter constructor
-template<typename T>
-inline void print( std::ostream & os, T && x, unsigned int indent ) {
-    print( os, std::forward<T>(x), Indenter{ Indenter::tabsize, indent });
+inline void print( std::ostream & os, const ast::Node * node, unsigned int indent ) {
+    print( os, node, Indenter{ Indenter::tabsize, indent });
 }
 

src/AST/Type.cpp

@@ -27 +27 @@
 namespace ast {
 
-const Type * Type::getComponent( unsigned i ) const {
+const Type * Type::getComponent( unsigned i ) {
         assertf( size() == 1 && i == 0, "Type::getComponent was called with size %d and index %d\n", size(), i );
         return this;
 }
 
-const Type * Type::stripDeclarator() const {
+const Type * Type::stripDeclarator() {
         const Type * t;
         const Type * a;
@@ -39 +39 @@
 }
 
-const Type * Type::stripReferences() const {
+const Type * Type::stripReferences() {
         const Type * t;
         const ReferenceType * r;

src/AST/Type.hpp

@@ -25 +25 @@
 #include "Decl.hpp"          // for AggregateDecl subclasses
 #include "Fwd.hpp"
-#include "Node.hpp"          // for Node, ptr, ptr_base
+#include "Node.hpp"          // for Node, ptr
 #include "TypeVar.hpp"
 #include "Visitor.hpp"
@@ -58 +58 @@
         virtual bool isVoid() const { return size() == 0; }
         /// Get the i'th component of this type
-        virtual const Type * getComponent( unsigned i ) const;
+        virtual const Type * getComponent( unsigned i );
 
         /// type without outer pointers and arrays
-        const Type * stripDeclarator() const;
+        const Type * stripDeclarator();
         /// type without outer references
-        const Type * stripReferences() const;
+        const Type * stripReferences();
         /// number of reference occuring consecutively on the outermost layer of this type
         /// (i.e. do not count references nested within other types)
@@ -75 +75 @@
         MUTATE_FRIEND
 };
-
-/// Set the `is_lvalue` qualifier on this type, cloning only if necessary
-template< enum Node::ref_type ref_t >
-void add_lvalue( ptr_base< Type, ref_t > & p ) {
-        if ( ! p->qualifiers.is_lvalue ) p.get_and_mutate()->qualifiers.is_lvalue = true;
-}
-
-/// Clear the qualifiers on this type, cloning only if necessary
-template< enum Node::ref_type ref_t >
-void clear_qualifiers( ptr_base< Type, ref_t > & p ) {
-        if ( p->qualifiers != CV::Qualifiers{} ) p.get_and_mutate()->qualifiers = CV::Qualifiers{};
-}
 
 /// `void`
@@ -449 +437 @@
         unsigned size() const override { return types.size(); }
 
-        const Type * getComponent( unsigned i ) const override {
+        const Type * getComponent( unsigned i ) override {
                 assertf( i < size(), "TupleType::getComponent: index %d must be less than size %d",
                         i, size() );

src/AST/module.mk

@@ -28 +28 @@
         AST/Print.cpp \
         AST/Stmt.cpp \
-        AST/SymbolTable.cpp \
         AST/Type.cpp \
-        AST/TypeEnvironment.cpp \
         AST/TypeSubstitution.cpp
 

src/AST/porting.md

@@ -104 +104 @@
           * `LinkageSpec::isMangled(Spec)` etc. => `Spec.is_mangled` etc.
           * `LinkageSpec::Intrinsic` etc. => `ast::Linkage::Intrinsic` etc.
-  * Boolean flags to `SymTab::Mangler::mangle` are now a `SymTab::Mangle::Mode` struct
-    * uses `bitfield`
-  * Because `Indexer` isn't a terribly evocative name:
-    * `SymTab::Indexer` => `ast::SymbolTable`
-    * `SymTab/Indexer.{h,cc}` => `AST/SymbolTable.{hpp,cpp}`
-    * **TODO** `WithIndexer` => `WithSymbolTable`
-      * `indexer` => `symTab`
-    * `IdData::deleteStmt` => `IdData::deleter`
-    * `lookupId()` now returns a vector rather than an out-param list
-    * To avoid name collisions:
-      * `SymTab::Mangler` => `Mangle`
-  * `ResolvExpr::TypeEnvironment` => `ast::TypeEnvironment`
-    * in `AST/TypeEnvironment.hpp`
 * Boolean constructor parameters get replaced with a dedicated flag enum:
   * e.g. `bool isVarLen;` => `enum LengthFlag { FixedLen, VariableLen };` `LengthFlag isVarLen;`
@@ -274 +261 @@
   * feature is `type@thing` e.g. `int@MAX`
 
-`referenceToRvalueConversion`
-* now returns `const Expr *` rather than mutating argument
-
-`printAssertionSet`, `printOpenVarSet`
-* `ostream &` now first argument, for consistency
-
-`EqvClass`
-* `type` => `bound`
-
-`TypeEnvironment`
-* `makeSubstitution()` => `writeToSubstitution()`
-* `isEmpty()` => `empty()`
-* removed `clone()` in favour of explicit copies
-
-`occurs`
-* moved to be helper function in `TypeEnvironment.cpp` (its only use)
-
 [1] https://gcc.gnu.org/onlinedocs/gcc-9.1.0/gcc/Type-Attributes.html#Type-Attributes
 

src/GenPoly/GenPoly.cc

@@ -24 +24 @@
 #include <vector>                       // for vector
 
-#include "AST/Type.hpp"
 #include "GenPoly/ErasableScopedMap.h"  // for ErasableScopedMap<>::const_it...
 #include "ResolvExpr/typeops.h"         // for flatten
@@ -263 +262 @@
                 } else {
                         return dynamic_cast< FunctionType* >( ty ); // pointer if FunctionType, NULL otherwise
-                }
-        }
-
-        const ast::FunctionType * getFunctionType( const ast::Type * ty ) {
-                if ( auto pty = dynamic_cast< const ast::PointerType * >( ty ) ) {
-                        return pty->base.as< ast::FunctionType >();
-                } else {
-                        return dynamic_cast< const ast::FunctionType * >( ty );
                 }
         }

src/GenPoly/GenPoly.h

@@ -20 +20 @@
 
 #include "ErasableScopedMap.h"    // for ErasableScopedMap
-#include "AST/Fwd.hpp"
 #include "SymTab/Mangler.h"       // for Mangler
 #include "SynTree/Declaration.h"  // for TypeDecl::Data, AggregateDecl, Type...
@@ -73 +72 @@
         /// Returns a pointer to the base FunctionType if ty is the type of a function (or pointer to one), NULL otherwise
         FunctionType *getFunctionType( Type *ty );
-        const ast::FunctionType * getFunctionType( const ast::Type * ty );
 
         /// If expr (after dereferencing N >= 0 pointers) is a variable expression, returns the variable expression, NULL otherwise;

src/InitTweak/InitTweak.cc

@@ -756 +756 @@
         }
 
-        bool isCopyFunction( const ast::FunctionDecl * decl ) {
-                const ast::FunctionType * ftype = decl->type;
-                if ( ftype->params.size() != 2 ) return false;
-
-                const ast::Type * t1 = getPointerBase( ftype->params.front()->get_type() );
-                if ( ! t1 ) return false;
-                const ast::Type * t2 = ftype->params.back()->get_type();
-                
-                return ResolvExpr::typesCompatibleIgnoreQualifiers( t1, t2, ast::SymbolTable{} );
-        }
-
         FunctionDecl * isAssignment( Declaration * decl ) {
                 return isCopyFunction( decl, "?=?" );

src/InitTweak/InitTweak.h

@@ -30 +30 @@
         FunctionDecl * isCopyConstructor( Declaration * decl );
         FunctionDecl * isCopyFunction( Declaration * decl, const std::string & fname );
-        bool isCopyFunction( const ast::FunctionDecl * decl );
 
         /// returns the base type of the first parameter to a constructor/destructor/assignment function

src/Makefile.in

@@ -170 +170 @@
         AST/Init.$(OBJEXT) AST/LinkageSpec.$(OBJEXT) \
         AST/Node.$(OBJEXT) AST/Pass.$(OBJEXT) AST/Print.$(OBJEXT) \
-        AST/Stmt.$(OBJEXT) AST/SymbolTable.$(OBJEXT) \
-        AST/Type.$(OBJEXT) AST/TypeEnvironment.$(OBJEXT) \
+        AST/Stmt.$(OBJEXT) AST/Type.$(OBJEXT) \
         AST/TypeSubstitution.$(OBJEXT)
 am__objects_2 = CodeGen/CodeGenerator.$(OBJEXT) \
@@ -587 +586 @@
         AST/Print.cpp \
         AST/Stmt.cpp \
-        AST/SymbolTable.cpp \
         AST/Type.cpp \
-        AST/TypeEnvironment.cpp \
         AST/TypeSubstitution.cpp
 
@@ -757 +754 @@
 AST/Print.$(OBJEXT): AST/$(am__dirstamp) AST/$(DEPDIR)/$(am__dirstamp)
 AST/Stmt.$(OBJEXT): AST/$(am__dirstamp) AST/$(DEPDIR)/$(am__dirstamp)
-AST/SymbolTable.$(OBJEXT): AST/$(am__dirstamp) \
-        AST/$(DEPDIR)/$(am__dirstamp)
 AST/Type.$(OBJEXT): AST/$(am__dirstamp) AST/$(DEPDIR)/$(am__dirstamp)
-AST/TypeEnvironment.$(OBJEXT): AST/$(am__dirstamp) \
-        AST/$(DEPDIR)/$(am__dirstamp)
 AST/TypeSubstitution.$(OBJEXT): AST/$(am__dirstamp) \
         AST/$(DEPDIR)/$(am__dirstamp)
@@ -1197 +1190 @@
 @AMDEP_TRUE@@am__include@ @am__quote@AST/$(DEPDIR)/Print.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@AST/$(DEPDIR)/Stmt.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@AST/$(DEPDIR)/SymbolTable.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@AST/$(DEPDIR)/Type.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@AST/$(DEPDIR)/TypeEnvironment.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@AST/$(DEPDIR)/TypeSubstitution.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@CodeGen/$(DEPDIR)/CodeGenerator.Po@am__quote@

src/ResolvExpr/AlternativeFinder.cc

@@ -28 +28 @@
 #include "Alternative.h"           // for AltList, Alternative
 #include "AlternativeFinder.h"
-#include "AST/Expr.hpp"
-#include "AST/Type.hpp"
 #include "Common/SemanticError.h"  // for SemanticError
 #include "Common/utility.h"        // for deleteAll, printAll, CodeLocation
@@ -224 +222 @@
                         cost.incReference();
                 }
-        }
-
-        const ast::Expr * referenceToRvalueConversion( const ast::Expr * expr, Cost & cost ) {
-                if ( expr->result.as< ast::ReferenceType >() ) {
-                        // cast away reference from expr
-                        cost.incReference();
-                        return new ast::CastExpr{ expr->location, expr, expr->result->stripReferences() };
-                }
-                
-                return expr;
         }
 

src/ResolvExpr/ResolveAssertions.cc

@@ -30 +30 @@
 #include "Common/Indenter.h"        // for Indenter
 #include "Common/utility.h"         // for sort_mins
-#include "GenPoly/GenPoly.h"        // for getFunctionType
 #include "ResolvExpr/RenameVars.h"  // for renameTyVars
 #include "SymTab/Indexer.h"         // for Indexer
@@ -155 +154 @@
                         Cost k = Cost::zero;
                         for ( const auto& assn : x.assns ) {
-                                // compute conversion cost from satisfying decl to assertion
                                 k += computeConversionCost( 
                                         assn.match.adjType, assn.decl->get_type(), indexer, x.env );
                                 
                                 // mark vars+specialization cost on function-type assertions
-                                FunctionType* func = GenPoly::getFunctionType( assn.match.cdata.id->get_type() );
+                                Type* assnType = assn.match.cdata.id->get_type();
+                                FunctionType* func;
+                                if ( PointerType* ptr = dynamic_cast< PointerType* >( assnType ) ) {
+                                        func = dynamic_cast< FunctionType* >( ptr->base );
+                                } else {
+                                        func = dynamic_cast< FunctionType* >( assnType );
+                                }
                                 if ( ! func ) continue;
                                 

src/ResolvExpr/Resolver.cc

@@ -7 +7 @@
 // Resolver.cc --
 //
-// Author           : Aaron B. Moss
+// Author           : Richard C. Bilson
 // Created On       : Sun May 17 12:17:01 2015
-// Last Modified By : Aaron B. Moss
-// Last Modified On : Wed May 29 11:00:00 2019
-// Update Count     : 241
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Tue Feb 19 18:09:56 2019
+// Update Count     : 240
 //
 
@@ -21 +21 @@
 #include "Alternative.h"                 // for Alternative, AltList
 #include "AlternativeFinder.h"           // for AlternativeFinder, resolveIn...
-#include "CurrentObject.h"               // for CurrentObject
-#include "RenameVars.h"                  // for RenameVars, global_renamer
-#include "Resolver.h"
-#include "ResolvMode.h"                  // for ResolvMode
-#include "typeops.h"                     // for extractResultType
-#include "Unify.h"                       // for unify
-#include "AST/Pass.hpp"
-#include "AST/SymbolTable.hpp"
 #include "Common/PassVisitor.h"          // for PassVisitor
 #include "Common/SemanticError.h"        // for SemanticError
 #include "Common/utility.h"              // for ValueGuard, group_iterate
+#include "CurrentObject.h"               // for CurrentObject
 #include "InitTweak/GenInit.h"
 #include "InitTweak/InitTweak.h"         // for isIntrinsicSingleArgCallStmt
+#include "RenameVars.h"                  // for RenameVars, global_renamer
 #include "ResolvExpr/TypeEnvironment.h"  // for TypeEnvironment
+#include "Resolver.h"
+#include "ResolvMode.h"                  // for ResolvMode
 #include "SymTab/Autogen.h"              // for SizeType
 #include "SymTab/Indexer.h"              // for Indexer
@@ -45 +41 @@
 #include "SynTree/Visitor.h"             // for acceptAll, maybeAccept
 #include "Tuples/Tuples.h"
+#include "typeops.h"                     // for extractResultType
+#include "Unify.h"                       // for unify
 #include "Validate/FindSpecialDecls.h"   // for SizeType
 
@@ -50 +48 @@
 
 namespace ResolvExpr {
-        struct Resolver_old final : public WithIndexer, public WithGuards, public WithVisitorRef<Resolver_old>, public WithShortCircuiting, public WithStmtsToAdd {
-                Resolver_old() {}
-                Resolver_old( const SymTab::Indexer & other ) {
+        struct Resolver final : public WithIndexer, public WithGuards, public WithVisitorRef<Resolver>, public WithShortCircuiting, public WithStmtsToAdd {
+                Resolver() {}
+                Resolver( const SymTab::Indexer & other ) {
                         indexer = other;
                 }
@@ -103 +101 @@
 
         void resolve( std::list< Declaration * > translationUnit ) {
-                PassVisitor<Resolver_old> resolver;
+                PassVisitor<Resolver> resolver;
                 acceptAll( translationUnit, resolver );
         }
 
         void resolveDecl( Declaration * decl, const SymTab::Indexer & indexer ) {
-                PassVisitor<Resolver_old> resolver( indexer );
+                PassVisitor<Resolver> resolver( indexer );
                 maybeAccept( decl, resolver );
         }
@@ -404 +402 @@
         }
 
-        void Resolver_old::previsit( ObjectDecl * objectDecl ) {
-                // To handle initialization of routine pointers, e.g., int (*fp)(int) = foo(), means that 
-                // class-variable initContext is changed multiple time because the LHS is analysed twice. 
-                // The second analysis changes initContext because of a function type can contain object 
-                // declarations in the return and parameter types. So each value of initContext is 
+        void Resolver::previsit( ObjectDecl * objectDecl ) {
+                // To handle initialization of routine pointers, e.g., int (*fp)(int) = foo(), means that
+                // class-variable initContext is changed multiple time because the LHS is analysed twice.
+                // The second analysis changes initContext because of a function type can contain object
+                // declarations in the return and parameter types. So each value of initContext is
                 // retained, so the type on the first analysis is preserved and used for selecting the RHS.
                 GuardValue( currentObject );
@@ -420 +418 @@
 
         template< typename PtrType >
-        void Resolver_old::handlePtrType( PtrType * type ) {
+        void Resolver::handlePtrType( PtrType * type ) {
                 if ( type->get_dimension() ) {
                         findSingleExpression( type->dimension, Validate::SizeType->clone(), indexer );
@@ -426 +424 @@
         }
 
-        void Resolver_old::previsit( ArrayType * at ) {
+        void Resolver::previsit( ArrayType * at ) {
                 handlePtrType( at );
         }
 
-        void Resolver_old::previsit( PointerType * pt ) {
+        void Resolver::previsit( PointerType * pt ) {
                 handlePtrType( pt );
         }
 
-        void Resolver_old::previsit( FunctionDecl * functionDecl ) {
+        void Resolver::previsit( FunctionDecl * functionDecl ) {
 #if 0
                 std::cerr << "resolver visiting functiondecl ";
@@ -444 +442 @@
         }
 
-        void Resolver_old::postvisit( FunctionDecl * functionDecl ) {
-                // default value expressions have an environment which shouldn't be there and trips up 
+        void Resolver::postvisit( FunctionDecl * functionDecl ) {
+                // default value expressions have an environment which shouldn't be there and trips up
                 // later passes.
                 // xxx - it might be necessary to somehow keep the information from this environment, but I
@@ -459 +457 @@
         }
 
-        void Resolver_old::previsit( EnumDecl * ) {
+        void Resolver::previsit( EnumDecl * ) {
                 // in case we decide to allow nested enums
                 GuardValue( inEnumDecl );
@@ -465 +463 @@
         }
 
-        void Resolver_old::previsit( StaticAssertDecl * assertDecl ) {
+        void Resolver::previsit( StaticAssertDecl * assertDecl ) {
                 findIntegralExpression( assertDecl->condition, indexer );
         }
 
-        void Resolver_old::previsit( ExprStmt * exprStmt ) {
+        void Resolver::previsit( ExprStmt * exprStmt ) {
                 visit_children = false;
                 assertf( exprStmt->expr, "ExprStmt has null Expression in resolver" );
@@ -475 +473 @@
         }
 
-        void Resolver_old::previsit( AsmExpr * asmExpr ) {
+        void Resolver::previsit( AsmExpr * asmExpr ) {
                 visit_children = false;
                 findVoidExpression( asmExpr->operand, indexer );
@@ -483 +481 @@
         }
 
-        void Resolver_old::previsit( AsmStmt * asmStmt ) {
+        void Resolver::previsit( AsmStmt * asmStmt ) {
                 visit_children = false;
                 acceptAll( asmStmt->get_input(), *visitor );
@@ -489 +487 @@
         }
 
-        void Resolver_old::previsit( IfStmt * ifStmt ) {
+        void Resolver::previsit( IfStmt * ifStmt ) {
                 findIntegralExpression( ifStmt->condition, indexer );
         }
 
-        void Resolver_old::previsit( WhileStmt * whileStmt ) {
+        void Resolver::previsit( WhileStmt * whileStmt ) {
                 findIntegralExpression( whileStmt->condition, indexer );
         }
 
-        void Resolver_old::previsit( ForStmt * forStmt ) {
+        void Resolver::previsit( ForStmt * forStmt ) {
                 if ( forStmt->condition ) {
                         findIntegralExpression( forStmt->condition, indexer );
@@ -507 +505 @@
         }
 
-        void Resolver_old::previsit( SwitchStmt * switchStmt ) {
+        void Resolver::previsit( SwitchStmt * switchStmt ) {
                 GuardValue( currentObject );
                 findIntegralExpression( switchStmt->condition, indexer );
@@ -514 +512 @@
         }
 
-        void Resolver_old::previsit( CaseStmt * caseStmt ) {
+        void Resolver::previsit( CaseStmt * caseStmt ) {
                 if ( caseStmt->condition ) {
                         std::list< InitAlternative > initAlts = currentObject.getOptions();
@@ -533 +531 @@
         }
 
-        void Resolver_old::previsit( BranchStmt * branchStmt ) {
+        void Resolver::previsit( BranchStmt * branchStmt ) {
                 visit_children = false;
                 // must resolve the argument for a computed goto
@@ -544 +542 @@
         }
 
-        void Resolver_old::previsit( ReturnStmt * returnStmt ) {
+        void Resolver::previsit( ReturnStmt * returnStmt ) {
                 visit_children = false;
                 if ( returnStmt->expr ) {
@@ -551 +549 @@
         }
 
-        void Resolver_old::previsit( ThrowStmt * throwStmt ) {
+        void Resolver::previsit( ThrowStmt * throwStmt ) {
                 visit_children = false;
                 // TODO: Replace *exception type with &exception type.
@@ -563 +561 @@
         }
 
-        void Resolver_old::previsit( CatchStmt * catchStmt ) {
+        void Resolver::previsit( CatchStmt * catchStmt ) {
                 if ( catchStmt->cond ) {
                         findSingleExpression( catchStmt->cond, new BasicType( noQualifiers, BasicType::Bool ), indexer );
@@ -578 +576 @@
         }
 
-        void Resolver_old::previsit( WaitForStmt * stmt ) {
+        void Resolver::previsit( WaitForStmt * stmt ) {
                 visit_children = false;
 
@@ -784 +782 @@
         }
 
-        void Resolver_old::previsit( SingleInit * singleInit ) {
+        void Resolver::previsit( SingleInit * singleInit ) {
                 visit_children = false;
                 // resolve initialization using the possibilities as determined by the currentObject cursor
@@ -836 +834 @@
         }
 
-        void Resolver_old::previsit( ListInit * listInit ) {
+        void Resolver::previsit( ListInit * listInit ) {
                 visit_children = false;
                 // move cursor into brace-enclosed initializer-list
@@ -871 +869 @@
 
         // ConstructorInit - fall back on C-style initializer
-        void Resolver_old::fallbackInit( ConstructorInit * ctorInit ) {
+        void Resolver::fallbackInit( ConstructorInit * ctorInit ) {
                 // could not find valid constructor, or found an intrinsic constructor
                 // fall back on C-style initializer
@@ -884 +882 @@
         void resolveCtorInit( ConstructorInit * ctorInit, const SymTab::Indexer & indexer ) {
                 assert( ctorInit );
-                PassVisitor<Resolver_old> resolver( indexer );
+                PassVisitor<Resolver> resolver( indexer );
                 ctorInit->accept( resolver );
         }
@@ -890 +888 @@
         void resolveStmtExpr( StmtExpr * stmtExpr, const SymTab::Indexer & indexer ) {
                 assert( stmtExpr );
-                PassVisitor<Resolver_old> resolver( indexer );
+                PassVisitor<Resolver> resolver( indexer );
                 stmtExpr->accept( resolver );
                 stmtExpr->computeResult();
@@ -896 +894 @@
         }
 
-        void Resolver_old::previsit( ConstructorInit * ctorInit ) {
+        void Resolver::previsit( ConstructorInit * ctorInit ) {
                 visit_children = false;
                 // xxx - fallback init has been removed => remove fallbackInit function and remove complexity from FixInit and remove C-init from ConstructorInit
@@ -930 +928 @@
                 // }
         }
-
-        ///////////////////////////////////////////////////////////////////////////
-        //
-        // *** NEW RESOLVER ***
-        //
-        ///////////////////////////////////////////////////////////////////////////
-
-        class Resolver_new final 
-        : public ast::WithIndexer, public ast::WithGuards, public ast::WithVisitorRef<Resolver_new>, 
-          public ast::WithShortCircuiting, public ast::WithStmtsToAdd<> {
-                  
-        public: 
-                Resolver_new() = default;
-                Resolver_new( const ast::SymbolTable & syms ) { /*symtab = syms;*/ }
-
-                void previsit( ast::FunctionDecl * functionDecl );
-                ast::DeclWithType * postvisit( ast::FunctionDecl * functionDecl );
-                void previsit( ast::ObjectDecl * objectDecl );
-                void previsit( ast::EnumDecl * enumDecl );
-                void previsit( ast::StaticAssertDecl * assertDecl );
-
-                void previsit( ast::ArrayType * at );
-                void previsit( ast::PointerType * pt );
-
-                void previsit( ast::ExprStmt * exprStmt );
-                void previsit( ast::AsmExpr * asmExpr );
-                void previsit( ast::AsmStmt * asmStmt );
-                void previsit( ast::IfStmt * ifStmt );
-                void previsit( ast::WhileStmt * whileStmt );
-                void previsit( ast::ForStmt * forStmt );
-                void previsit( ast::SwitchStmt * switchStmt );
-                void previsit( ast::CaseStmt * caseStmt );
-                void previsit( ast::BranchStmt * branchStmt );
-                void previsit( ast::ReturnStmt * returnStmt );
-                void previsit( ast::ThrowStmt * throwStmt );
-                void previsit( ast::CatchStmt * catchStmt );
-                void previsit( ast::WaitForStmt * stmt );
-
-                void previsit( ast::SingleInit * singleInit );
-                void previsit( ast::ListInit * listInit );
-                void previsit( ast::ConstructorInit * ctorInit );
-        };
-
-        void resolve( std::list< ast::ptr<ast::Decl> >& translationUnit ) {
-                ast::Pass<Resolver_new> resolver;
-                accept_all( translationUnit, resolver );
-        }
-
-        void previsit( ast::FunctionDecl * functionDecl ) {
-                #warning unimplemented; Resolver port in progress
-                (void)functionDecl;
-                assert(false);
-        }
-
-        ast::DeclWithType * postvisit( ast::FunctionDecl * functionDecl ) {
-                #warning unimplemented; Resolver port in progress
-                (void)functionDecl;
-                assert(false);
-                return nullptr;
-        }
-
-        void previsit( ast::ObjectDecl * objectDecl ) {
-                #warning unimplemented; Resolver port in progress
-                (void)objectDecl;
-                assert(false);
-        }
-
-        void previsit( ast::EnumDecl * enumDecl ) {
-                #warning unimplemented; Resolver port in progress
-                (void)enumDecl;
-                assert(false);
-        }
-
-        void previsit( ast::StaticAssertDecl * assertDecl ) {
-                #warning unimplemented; Resolver port in progress
-                (void)assertDecl;
-                assert(false);
-        }
-
-        void previsit( ast::ArrayType * at ) {
-                #warning unimplemented; Resolver port in progress
-                (void)at;
-                assert(false);
-        }
-
-        void previsit( ast::PointerType * pt ) {
-                #warning unimplemented; Resolver port in progress
-                (void)pt;
-                assert(false);
-        }
-
-        void previsit( ast::ExprStmt * exprStmt ) {
-                #warning unimplemented; Resolver port in progress
-                (void)exprStmt;
-                assert(false);
-        }
-
-        void previsit( ast::AsmExpr * asmExpr ) {
-                #warning unimplemented; Resolver port in progress
-                (void)asmExpr;
-                assert(false);
-        }
-
-        void previsit( ast::AsmStmt * asmStmt ) {
-                #warning unimplemented; Resolver port in progress
-                (void)asmStmt;
-                assert(false);
-        }
-
-        void previsit( ast::IfStmt * ifStmt ) {
-                #warning unimplemented; Resolver port in progress
-                (void)ifStmt;
-                assert(false);
-        }
-
-        void previsit( ast::WhileStmt * whileStmt ) {
-                #warning unimplemented; Resolver port in progress
-                (void)whileStmt;
-                assert(false);
-        }
-
-        void previsit( ast::ForStmt * forStmt ) {
-                #warning unimplemented; Resolver port in progress
-                (void)forStmt;
-                assert(false);
-        }
-
-        void previsit( ast::SwitchStmt * switchStmt ) {
-                #warning unimplemented; Resolver port in progress
-                (void)switchStmt;
-                assert(false);
-        }
-
-        void previsit( ast::CaseStmt * caseStmt ) {
-                #warning unimplemented; Resolver port in progress
-                (void)caseStmt;
-                assert(false);
-        }
-
-        void previsit( ast::BranchStmt * branchStmt ) {
-                #warning unimplemented; Resolver port in progress
-                (void)branchStmt;
-                assert(false);
-        }
-
-        void previsit( ast::ReturnStmt * returnStmt ) {
-                #warning unimplemented; Resolver port in progress
-                (void)returnStmt;
-                assert(false);
-        }
-
-        void previsit( ast::ThrowStmt * throwStmt ) {
-                #warning unimplemented; Resolver port in progress
-                (void)throwStmt;
-                assert(false);
-        }
-
-        void previsit( ast::CatchStmt * catchStmt ) {
-                #warning unimplemented; Resolver port in progress
-                (void)catchStmt;
-                assert(false);
-        }
-
-        void previsit( ast::WaitForStmt * stmt ) {
-                #warning unimplemented; Resolver port in progress
-                (void)stmt;
-                assert(false);
-        }
-
-        void previsit( ast::SingleInit * singleInit ) {
-                #warning unimplemented; Resolver port in progress
-                (void)singleInit;
-                assert(false);
-        }
-
-        void previsit( ast::ListInit * listInit ) {
-                #warning unimplemented; Resolver port in progress
-                (void)listInit;
-                assert(false);
-        }
-
-        void previsit( ast::ConstructorInit * ctorInit ) {
-                #warning unimplemented; Resolver port in progress
-                (void)ctorInit;
-                assert(false);
-        }
-
 } // namespace ResolvExpr
 

src/ResolvExpr/Resolver.h

@@ -16 +16 @@
 #pragma once
 
-#include <list>          // for list
-#include <AST/Node.hpp>  // for ptr
+#include <list>  // for list
 
 class ConstructorInit;
@@ -24 +23 @@
 class StmtExpr;
 namespace SymTab {
-        class Indexer;
-} // namespace SymTab
-
-namespace ast {
-        class Decl;
-} // namespace ast
+class Indexer;
+}  // namespace SymTab
 
 namespace ResolvExpr {
@@ -45 +40 @@
         /// Resolves with-stmts and with-clauses on functions
         void resolveWithExprs( std::list< Declaration * > & translationUnit );
-
-        /// Checks types and binds syntactic constructs to typed representations
-        void resolve( std::list< ast::ptr<ast::Decl> >& translationUnit );
 } // namespace ResolvExpr
 

src/ResolvExpr/Unify.cc

@@ -14 +14 @@
 //
 
-#include <cassert>                  // for assertf, assert
-#include <iterator>                 // for back_insert_iterator, back_inserter
-#include <map>                      // for _Rb_tree_const_iterator, _Rb_tree_i...
-#include <memory>                   // for unique_ptr
-#include <set>                      // for set
-#include <string>                   // for string, operator==, operator!=, bas...
-#include <utility>                  // for pair, move
+#include <cassert>                // for assertf, assert
+#include <iterator>               // for back_insert_iterator, back_inserter
+#include <map>                    // for _Rb_tree_const_iterator, _Rb_tree_i...
+#include <memory>                 // for unique_ptr
+#include <set>                    // for set
+#include <string>                 // for string, operator==, operator!=, bas...
+#include <utility>                // for pair, move
 #include <vector>
 
 #include "AST/Node.hpp"
 #include "AST/Type.hpp"
-#include "AST/TypeEnvironment.hpp"
-#include "Common/PassVisitor.h"     // for PassVisitor
-#include "FindOpenVars.h"           // for findOpenVars
-#include "Parser/LinkageSpec.h"     // for C
-#include "SynTree/Constant.h"       // for Constant
-#include "SynTree/Declaration.h"    // for TypeDecl, TypeDecl::Data, Declarati...
-#include "SynTree/Expression.h"     // for TypeExpr, Expression, ConstantExpr
-#include "SynTree/Mutator.h"        // for Mutator
-#include "SynTree/Type.h"           // for Type, TypeInstType, FunctionType
-#include "SynTree/Visitor.h"        // for Visitor
-#include "Tuples/Tuples.h"          // for isTtype
-#include "TypeEnvironment.h"        // for EqvClass, AssertionSet, OpenVarSet
+#include "Common/PassVisitor.h"   // for PassVisitor
+#include "FindOpenVars.h"         // for findOpenVars
+#include "Parser/LinkageSpec.h"   // for C
+#include "SynTree/Constant.h"     // for Constant
+#include "SynTree/Declaration.h"  // for TypeDecl, TypeDecl::Data, Declarati...
+#include "SynTree/Expression.h"   // for TypeExpr, Expression, ConstantExpr
+#include "SynTree/Mutator.h"      // for Mutator
+#include "SynTree/Type.h"         // for Type, TypeInstType, FunctionType
+#include "SynTree/Visitor.h"      // for Visitor
+#include "Tuples/Tuples.h"        // for isTtype
+#include "TypeEnvironment.h"      // for EqvClass, AssertionSet, OpenVarSet
 #include "Unify.h"
-#include "typeops.h"                // for flatten, occurs, commonType
+#include "typeops.h"              // for flatten, occurs, commonType
 
 namespace SymTab {
@@ -107 +106 @@
                 delete newSecond;
                 return result;
-        }
-
-        bool typesCompatible( 
-                        const ast::Type * first, const ast::Type * second, const ast::SymbolTable & symtab, 
-                        const ast::TypeEnvironment & env ) {
-                #warning unimplemented
-                assert((first, second, symtab, env, false));
-                return false;
         }
 
@@ -139 +130 @@
                 delete newSecond;
                 return result;
-        }
-
-        bool typesCompatibleIgnoreQualifiers( 
-                        const ast::Type * first, const ast::Type * second, const ast::SymbolTable & symtab, 
-                        const ast::TypeEnvironment & env ) {
-                #warning unimplemented
-                assert((first, second, symtab, env, false));
-                return false;
         }
 
@@ -280 +263 @@
         }
 
-        bool unifyInexact( 
-                        const ast::Type * type1, const ast::Type * type2, ast::TypeEnvironment & env, 
-                        ast::AssertionSet & need, ast::AssertionSet & have, const ast::OpenVarSet & openVars, 
-                        WidenMode widenMode, const ast::SymbolTable & symtab, const ast::Type *& common ) {
-                #warning unimplemented
-                assert((type1, type2, env, need, have, openVars, widenMode, symtab, common, false));
-                return false;
-        }
-
         Unify::Unify( Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer )
                 : result( false ), type2( type2 ), env( env ), needAssertions( needAssertions ), haveAssertions( haveAssertions ), openVars( openVars ), widenMode( widenMode ), indexer( indexer ) {

src/ResolvExpr/Unify.h

@@ -18 +18 @@
 #include <list>                   // for list
 
-#include "AST/TypeEnvironment.hpp"  // for TypeEnvironment, AssertionSet, OpenVarSet
 #include "Common/utility.h"       // for deleteAll
 #include "SynTree/Declaration.h"  // for TypeDecl, TypeDecl::Data
 #include "TypeEnvironment.h"      // for AssertionSet, OpenVarSet
-#include "WidenMode.h"              // for WidenMode
+#include "WidenMode.h"            // for WidenMode
 
 class Type;
 class TypeInstType;
 namespace SymTab {
-        class Indexer;
-}
-
-namespace ast {
-        class SymbolTable;
-        class Type;
-}
+class Indexer;
+}  // namespace SymTab
 
 namespace ResolvExpr {
@@ -68 +62 @@
         }
 
-        bool unifyInexact( 
-                const ast::Type * type1, const ast::Type * type2, ast::TypeEnvironment & env, 
-                ast::AssertionSet & need, ast::AssertionSet & have, const ast::OpenVarSet & openVars, 
-                WidenMode widenMode, const ast::SymbolTable & symtab, const ast::Type *& common );
-
 } // namespace ResolvExpr
 

src/ResolvExpr/typeops.h

@@ -18 +18 @@
 #include <vector>
 
-#include "AST/Fwd.hpp"
 #include "AST/Node.hpp"
-#include "AST/SymbolTable.hpp"
 #include "AST/Type.hpp"
-#include "AST/TypeEnvironment.hpp"
 #include "SynTree/SynTree.h"
 #include "SynTree/Type.h"
@@ -102 +99 @@
         }
 
-        bool typesCompatible( 
-                const ast::Type *, const ast::Type *, const ast::SymbolTable &, 
-                const ast::TypeEnvironment & env = {} );
-        
-        bool typesCompatibleIgnoreQualifiers(
-                const ast::Type *, const ast::Type *, const ast::SymbolTable &, 
-                const ast::TypeEnvironment & env = {} );
-
         /// creates the type represented by the list of returnVals in a FunctionType. The caller owns the return value.
         Type * extractResultType( FunctionType * functionType );
@@ -126 +115 @@
         // in Occurs.cc
         bool occurs( Type *type, std::string varName, const TypeEnvironment &env );
-        // new AST version in TypeEnvironment.cpp (only place it was used in old AST)
 
         template<typename Iter> 
@@ -139 +127 @@
         // in AlternativeFinder.cc
         void referenceToRvalueConversion( Expression *& expr, Cost & cost );
-        const ast::Expr * referenceToRvalueConversion( const ast::Expr * expr, Cost & cost );
 
         // flatten tuple type into list of types

src/SymTab/Mangler.cc

@@ -390 +390 @@
 } // namespace SymTab
 
-namespace Mangle {
-        std::string mangle( const ast::Node * decl, Mangle::Mode mode ) {
-                #warning unimplemented
-                assert( decl && mode.val && false );
-                return "";
-        }
-} // namespace Mangle
-
 // Local Variables: //
 // tab-width: 4 //

src/SymTab/Mangler.h

@@ -21 +21 @@
 #include <utility>            // for pair
 
-#include "AST/Bitfield.hpp"
-#include "AST/Fwd.hpp"
 #include "SynTree/SynTree.h"  // for Types
 #include "SynTree/Visitor.h"  // for Visitor, maybeAccept
@@ -77 +75 @@
 } // SymTab
 
-namespace Mangle {
-        /// Bitflags for mangle modes
-        enum {
-                NoOverrideable  = 1 << 0,
-                Type            = 1 << 1,
-                NoGenericParams = 1 << 2
-        };
-
-        /// Bitflag type for mangler modes
-        struct mangle_flags {
-                union {
-                        unsigned int val;
-                        struct {
-                                bool no_overrideable   : 1;
-                                bool type              : 1;
-                                bool no_generic_params : 1;
-                        };
-                };
-
-                constexpr mangle_flags( unsigned int val ) : val(val) {}
-        };
-
-        using Mode = bitfield<mangle_flags>;
-
-        /// Mangle declaration name
-        std::string mangle( const ast::Node * decl, Mode mode = {} );
-
-        namespace Encoding {
-                using namespace SymTab::Mangler::Encoding;
-        };
-}
-
 extern "C" {
         char * cforall_demangle(const char *, int);