Changeset 24d6572 for src/ResolvExpr/Unify.h

Timestamp:

Jun 12, 2023, 2:45:32 PM (2 years ago)

Author:

Fangren Yu <f37yu@…>

Branches:

ast-experimental, master

Children:

62d62db

Parents:

34b4268 (diff), 251ce80 (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' into ast-experimental

File:

• src/ResolvExpr/Unify.h (modified) (2 diffs)

src/ResolvExpr/Unify.h

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 13:09:04 2015
-// Last Modified By : Aaron B. Moss
-// Last Modified On : Mon Jun 18 11:58:00 2018
-// Update Count     : 4
+// Last Modified By : Andrew Beach
+// Last Modified On : Tue Jan 17 11:12:00 2023
+// Update Count     : 5
 //
 
@@ -37 +37 @@
 
 namespace ResolvExpr {
-        bool unify( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, OpenVarSet &openVars, const SymTab::Indexer &indexer );
-        bool unify( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, OpenVarSet &openVars, const SymTab::Indexer &indexer, Type *&commonType );
-        bool unifyExact( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, OpenVarSet &openVars, const SymTab::Indexer &indexer );
-        bool unifyInexact( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widen, const SymTab::Indexer &indexer, Type *&common );
 
-        template< typename Iterator1, typename Iterator2 >
-        bool unifyList( Iterator1 list1Begin, Iterator1 list1End, Iterator2 list2Begin, Iterator2 list2End, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, OpenVarSet &openVars, const SymTab::Indexer &indexer, std::list< Type* > &commonTypes ) {
-                for ( ; list1Begin != list1End && list2Begin != list2End; ++list1Begin, ++list2Begin ) {
-                        Type *commonType = 0;
-                        if ( ! unify( *list1Begin, *list2Begin, env, needAssertions, haveAssertions, openVars, indexer, commonType ) ) {
-                                return false;
-                        } // if
-                        commonTypes.push_back( commonType );
-                } // for
-                if ( list1Begin != list1End || list2Begin != list2End ) {
-                        return false;
-                } else {
-                        return true;
-                } // if
-        }
+bool unify( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, OpenVarSet &openVars, const SymTab::Indexer &indexer );
+bool unify( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, OpenVarSet &openVars, const SymTab::Indexer &indexer, Type *&commonType );
+bool unifyExact( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, OpenVarSet &openVars, const SymTab::Indexer &indexer );
+bool unifyInexact( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widen, const SymTab::Indexer &indexer, Type *&common );
 
-        template< typename Iterator1, typename Iterator2 >
-        bool unifyList( Iterator1 list1Begin, Iterator1 list1End, Iterator2 list2Begin, Iterator2 list2End, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, OpenVarSet &openVars, const SymTab::Indexer &indexer ) {
-                std::list< Type* > commonTypes;
-                if ( unifyList( list1Begin, list1End, list2Begin, list2End, env, needAssertions, haveAssertions, openVars, indexer, commonTypes ) ) {
-                        deleteAll( commonTypes );
-                        return true;
-                } else {
-                        return false;
-                } // if
-        }
+bool typesCompatible( const Type *, const Type *, const SymTab::Indexer & indexer, const TypeEnvironment & env );
+bool typesCompatibleIgnoreQualifiers( const Type *, const Type *, const SymTab::Indexer & indexer, const TypeEnvironment & env );
 
-        bool unify( 
-                const ast::ptr<ast::Type> & type1, const ast::ptr<ast::Type> & type2, 
-                ast::TypeEnvironment & env, ast::AssertionSet & need, ast::AssertionSet & have, 
-                ast::OpenVarSet & open, const ast::SymbolTable & symtab );
+inline bool typesCompatible( const Type * t1, const Type * t2, const SymTab::Indexer & indexer ) {
+        TypeEnvironment env;
+        return typesCompatible( t1, t2, indexer, env );
+}
 
-        bool unify( 
-                const ast::ptr<ast::Type> & type1, const ast::ptr<ast::Type> & type2, 
-                ast::TypeEnvironment & env, ast::AssertionSet & need, ast::AssertionSet & have, 
-                ast::OpenVarSet & open, const ast::SymbolTable & symtab, ast::ptr<ast::Type> & common );
+inline bool typesCompatibleIgnoreQualifiers( const Type * t1, const Type * t2, const SymTab::Indexer & indexer ) {
+        TypeEnvironment env;
+        return typesCompatibleIgnoreQualifiers( t1, t2, indexer, env );
+}
 
-        bool unifyExact( 
-                const ast::Type * type1, const ast::Type * type2, ast::TypeEnvironment & env, 
-                ast::AssertionSet & need, ast::AssertionSet & have, const ast::OpenVarSet & open, 
-                WidenMode widen, const ast::SymbolTable & symtab );
+bool unify(
+        const ast::ptr<ast::Type> & type1, const ast::ptr<ast::Type> & type2,
+        ast::TypeEnvironment & env, ast::AssertionSet & need, ast::AssertionSet & have,
+        ast::OpenVarSet & open );
 
-        bool unifyInexact( 
-                const ast::ptr<ast::Type> & type1, const ast::ptr<ast::Type> & type2, 
-                ast::TypeEnvironment & env, ast::AssertionSet & need, ast::AssertionSet & have, 
-                const ast::OpenVarSet & open, WidenMode widen, const ast::SymbolTable & symtab, 
-                ast::ptr<ast::Type> & common );
+bool unify(
+        const ast::ptr<ast::Type> & type1, const ast::ptr<ast::Type> & type2,
+        ast::TypeEnvironment & env, ast::AssertionSet & need, ast::AssertionSet & have,
+        ast::OpenVarSet & open, ast::ptr<ast::Type> & common );
+
+bool unifyExact(
+        const ast::Type * type1, const ast::Type * type2, ast::TypeEnvironment & env,
+        ast::AssertionSet & need, ast::AssertionSet & have, const ast::OpenVarSet & open,
+        WidenMode widen );
+
+bool unifyInexact(
+        const ast::ptr<ast::Type> & type1, const ast::ptr<ast::Type> & type2,
+        ast::TypeEnvironment & env, ast::AssertionSet & need, ast::AssertionSet & have,
+        const ast::OpenVarSet & open, WidenMode widen, 
+        ast::ptr<ast::Type> & common );
+
+bool typesCompatible(
+        const ast::Type *, const ast::Type *, 
+        const ast::TypeEnvironment & env = {} );
+
+bool typesCompatibleIgnoreQualifiers(
+        const ast::Type *, const ast::Type *,
+        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 );
+/// Creates or extracts the type represented by returns in a `FunctionType`.
+ast::ptr<ast::Type> extractResultType( const ast::FunctionType * func );
+
+std::vector<ast::ptr<ast::Type>> flattenList(
+        const std::vector<ast::ptr<ast::Type>> & src, ast::TypeEnvironment & env
+);
 
 } // namespace ResolvExpr