Changeset d76c588 for src/ResolvExpr

Timestamp:

May 30, 2019, 4:10:24 PM (5 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

8d70648

Parents:

eba615c

Message:

Stubs for new resolver, implementation of new indexer, type environment

Location:

src/ResolvExpr

Files:

• AlternativeFinder.cc (modified) (2 diffs)
• ResolveAssertions.cc (modified) (2 diffs)
• Resolver.cc (modified) (27 diffs)
• Resolver.h (modified) (3 diffs)
• Unify.cc (modified) (4 diffs)
• Unify.h (modified) (2 diffs)
• typeops.h (modified) (4 diffs)

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
@@ -222 +224 @@
                         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
@@ -154 +155 @@
                         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
-                                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 );
-                                }
+                                FunctionType* func = GenPoly::getFunctionType( assn.match.cdata.id->get_type() );
                                 if ( ! func ) continue;
                                 

src/ResolvExpr/Resolver.cc

@@ -7 +7 @@
 // Resolver.cc --
 //
-// Author           : Richard C. Bilson
+// Author           : Aaron B. Moss
 // Created On       : Sun May 17 12:17:01 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Feb 19 18:09:56 2019
-// Update Count     : 240
+// Last Modified By : Aaron B. Moss
+// Last Modified On : Wed May 29 11:00:00 2019
+// Update Count     : 241
 //
 
@@ -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
@@ -41 +45 @@
 #include "SynTree/Visitor.h"             // for acceptAll, maybeAccept
 #include "Tuples/Tuples.h"
-#include "typeops.h"                     // for extractResultType
-#include "Unify.h"                       // for unify
 
 using namespace std;
 
 namespace ResolvExpr {
-        struct Resolver final : public WithIndexer, public WithGuards, public WithVisitorRef<Resolver>, public WithShortCircuiting, public WithStmtsToAdd {
-                Resolver() {}
-                Resolver( const SymTab::Indexer & other ) {
+        struct Resolver_old final : public WithIndexer, public WithGuards, public WithVisitorRef<Resolver_old>, public WithShortCircuiting, public WithStmtsToAdd {
+                Resolver_old() {}
+                Resolver_old( const SymTab::Indexer & other ) {
                         indexer = other;
                 }
@@ -100 +102 @@
 
         void resolve( std::list< Declaration * > translationUnit ) {
-                PassVisitor<Resolver> resolver;
+                PassVisitor<Resolver_old> resolver;
                 acceptAll( translationUnit, resolver );
         }
 
         void resolveDecl( Declaration * decl, const SymTab::Indexer & indexer ) {
-                PassVisitor<Resolver> resolver( indexer );
+                PassVisitor<Resolver_old> resolver( indexer );
                 maybeAccept( decl, resolver );
         }
@@ -401 +403 @@
         }
 
-        void Resolver::previsit( ObjectDecl * objectDecl ) {
+        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. 
@@ -417 +419 @@
 
         template< typename PtrType >
-        void Resolver::handlePtrType( PtrType * type ) {
+        void Resolver_old::handlePtrType( PtrType * type ) {
                 if ( type->get_dimension() ) {
                         findSingleExpression( type->dimension, SymTab::SizeType->clone(), indexer );
@@ -423 +425 @@
         }
 
-        void Resolver::previsit( ArrayType * at ) {
+        void Resolver_old::previsit( ArrayType * at ) {
                 handlePtrType( at );
         }
 
-        void Resolver::previsit( PointerType * pt ) {
+        void Resolver_old::previsit( PointerType * pt ) {
                 handlePtrType( pt );
         }
 
-        void Resolver::previsit( FunctionDecl * functionDecl ) {
+        void Resolver_old::previsit( FunctionDecl * functionDecl ) {
 #if 0
                 std::cerr << "resolver visiting functiondecl ";
@@ -441 +443 @@
         }
 
-        void Resolver::postvisit( FunctionDecl * functionDecl ) {
+        void Resolver_old::postvisit( FunctionDecl * functionDecl ) {
                 // default value expressions have an environment which shouldn't be there and trips up 
                 // later passes.
@@ -456 +458 @@
         }
 
-        void Resolver::previsit( EnumDecl * ) {
+        void Resolver_old::previsit( EnumDecl * ) {
                 // in case we decide to allow nested enums
                 GuardValue( inEnumDecl );
@@ -462 +464 @@
         }
 
-        void Resolver::previsit( StaticAssertDecl * assertDecl ) {
+        void Resolver_old::previsit( StaticAssertDecl * assertDecl ) {
                 findIntegralExpression( assertDecl->condition, indexer );
         }
 
-        void Resolver::previsit( ExprStmt * exprStmt ) {
+        void Resolver_old::previsit( ExprStmt * exprStmt ) {
                 visit_children = false;
                 assertf( exprStmt->expr, "ExprStmt has null Expression in resolver" );
@@ -472 +474 @@
         }
 
-        void Resolver::previsit( AsmExpr * asmExpr ) {
+        void Resolver_old::previsit( AsmExpr * asmExpr ) {
                 visit_children = false;
                 findVoidExpression( asmExpr->operand, indexer );
@@ -480 +482 @@
         }
 
-        void Resolver::previsit( AsmStmt * asmStmt ) {
+        void Resolver_old::previsit( AsmStmt * asmStmt ) {
                 visit_children = false;
                 acceptAll( asmStmt->get_input(), *visitor );
@@ -486 +488 @@
         }
 
-        void Resolver::previsit( IfStmt * ifStmt ) {
+        void Resolver_old::previsit( IfStmt * ifStmt ) {
                 findIntegralExpression( ifStmt->condition, indexer );
         }
 
-        void Resolver::previsit( WhileStmt * whileStmt ) {
+        void Resolver_old::previsit( WhileStmt * whileStmt ) {
                 findIntegralExpression( whileStmt->condition, indexer );
         }
 
-        void Resolver::previsit( ForStmt * forStmt ) {
+        void Resolver_old::previsit( ForStmt * forStmt ) {
                 if ( forStmt->condition ) {
                         findIntegralExpression( forStmt->condition, indexer );
@@ -504 +506 @@
         }
 
-        void Resolver::previsit( SwitchStmt * switchStmt ) {
+        void Resolver_old::previsit( SwitchStmt * switchStmt ) {
                 GuardValue( currentObject );
                 findIntegralExpression( switchStmt->condition, indexer );
@@ -511 +513 @@
         }
 
-        void Resolver::previsit( CaseStmt * caseStmt ) {
+        void Resolver_old::previsit( CaseStmt * caseStmt ) {
                 if ( caseStmt->condition ) {
                         std::list< InitAlternative > initAlts = currentObject.getOptions();
@@ -530 +532 @@
         }
 
-        void Resolver::previsit( BranchStmt * branchStmt ) {
+        void Resolver_old::previsit( BranchStmt * branchStmt ) {
                 visit_children = false;
                 // must resolve the argument for a computed goto
@@ -541 +543 @@
         }
 
-        void Resolver::previsit( ReturnStmt * returnStmt ) {
+        void Resolver_old::previsit( ReturnStmt * returnStmt ) {
                 visit_children = false;
                 if ( returnStmt->expr ) {
@@ -548 +550 @@
         }
 
-        void Resolver::previsit( ThrowStmt * throwStmt ) {
+        void Resolver_old::previsit( ThrowStmt * throwStmt ) {
                 visit_children = false;
                 // TODO: Replace *exception type with &exception type.
@@ -560 +562 @@
         }
 
-        void Resolver::previsit( CatchStmt * catchStmt ) {
+        void Resolver_old::previsit( CatchStmt * catchStmt ) {
                 if ( catchStmt->cond ) {
                         findSingleExpression( catchStmt->cond, new BasicType( noQualifiers, BasicType::Bool ), indexer );
@@ -575 +577 @@
         }
 
-        void Resolver::previsit( WaitForStmt * stmt ) {
+        void Resolver_old::previsit( WaitForStmt * stmt ) {
                 visit_children = false;
 
@@ -781 +783 @@
         }
 
-        void Resolver::previsit( SingleInit * singleInit ) {
+        void Resolver_old::previsit( SingleInit * singleInit ) {
                 visit_children = false;
                 // resolve initialization using the possibilities as determined by the currentObject cursor
@@ -833 +835 @@
         }
 
-        void Resolver::previsit( ListInit * listInit ) {
+        void Resolver_old::previsit( ListInit * listInit ) {
                 visit_children = false;
                 // move cursor into brace-enclosed initializer-list
@@ -868 +870 @@
 
         // ConstructorInit - fall back on C-style initializer
-        void Resolver::fallbackInit( ConstructorInit * ctorInit ) {
+        void Resolver_old::fallbackInit( ConstructorInit * ctorInit ) {
                 // could not find valid constructor, or found an intrinsic constructor
                 // fall back on C-style initializer
@@ -881 +883 @@
         void resolveCtorInit( ConstructorInit * ctorInit, const SymTab::Indexer & indexer ) {
                 assert( ctorInit );
-                PassVisitor<Resolver> resolver( indexer );
+                PassVisitor<Resolver_old> resolver( indexer );
                 ctorInit->accept( resolver );
         }
@@ -887 +889 @@
         void resolveStmtExpr( StmtExpr * stmtExpr, const SymTab::Indexer & indexer ) {
                 assert( stmtExpr );
-                PassVisitor<Resolver> resolver( indexer );
+                PassVisitor<Resolver_old> resolver( indexer );
                 stmtExpr->accept( resolver );
                 stmtExpr->computeResult();
@@ -893 +895 @@
         }
 
-        void Resolver::previsit( ConstructorInit * ctorInit ) {
+        void Resolver_old::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
@@ -927 +929 @@
                 // }
         }
+
+        ///////////////////////////////////////////////////////////////////////////
+        //
+        // *** 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 <list>          // for list
+#include <AST/Node.hpp>  // for ptr
 
 class ConstructorInit;
@@ -23 +24 @@
 class StmtExpr;
 namespace SymTab {
-class Indexer;
-}  // namespace SymTab
+        class Indexer;
+} // namespace SymTab
+
+namespace ast {
+        class Decl;
+} // namespace ast
 
 namespace ResolvExpr {
@@ -40 +45 @@
         /// 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 "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 "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 "Unify.h"
-#include "typeops.h"              // for flatten, occurs, commonType
+#include "typeops.h"                // for flatten, occurs, commonType
 
 namespace SymTab {
@@ -106 +107 @@
                 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;
         }
 
@@ -130 +139 @@
                 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;
         }
 
@@ -263 +280 @@
         }
 
+        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 SymTab
+        class Indexer;
+}
+
+namespace ast {
+        class SymbolTable;
+        class Type;
+}
 
 namespace ResolvExpr {
@@ -62 +68 @@
         }
 
+        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"
@@ -99 +102 @@
         }
 
+        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 );
@@ -115 +126 @@
         // 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> 
@@ -127 +139 @@
         // 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