Changeset b067d9b for src/ResolvExpr/typeops.h

Timestamp:

Oct 29, 2019, 4:01:24 PM (6 years ago)

Author:

Thierry Delisle <tdelisle@…>

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:

773db65, 9421f3d8

Parents:

7951100 (diff), 8364209 (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

File:

• src/ResolvExpr/typeops.h (modified) (6 diffs)

src/ResolvExpr/typeops.h

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 07:28:22 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 22 09:36:18 2017
-// Update Count     : 3
+// Last Modified By : Andrew Beach
+// Last Modified On : Thu Aug  8 16:36:00 2019
+// Update Count     : 5
 //
 
@@ -18 +18 @@
 #include <vector>
 
+#include "Cost.h"
+#include "TypeEnvironment.h"
+#include "WidenMode.h"
+#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"
-#include "SymTab/Indexer.h"
-#include "Cost.h"
-#include "TypeEnvironment.h"
+
+namespace SymTab {
+        class Indexer;
+}
 
 namespace ResolvExpr {
@@ -54 +63 @@
         // in AdjustExprType.cc
         /// Replaces array types with the equivalent pointer, and function types with a pointer-to-function
-        void adjustExprType( Type *&type, const TypeEnvironment &env, const SymTab::Indexer &indexer );
+        void adjustExprType( Type *& type, const TypeEnvironment & env, const SymTab::Indexer & indexer );
 
         /// Replaces array types with the equivalent pointer, and function types with a pointer-to-function using empty TypeEnvironment and Indexer
@@ -60 +69 @@
 
         template< typename ForwardIterator >
-        void adjustExprTypeList( ForwardIterator begin, ForwardIterator end, const TypeEnvironment &env, const SymTab::Indexer &indexer ) {
+        void adjustExprTypeList( ForwardIterator begin, ForwardIterator end, const TypeEnvironment & env, const SymTab::Indexer & indexer ) {
                 while ( begin != end ) {
                         adjustExprType( *begin++, env, indexer );
@@ -66 +75 @@
         }
 
+        /// Replaces array types with equivalent pointer, and function types with a pointer-to-function
+        const ast::Type * adjustExprType(
+                const ast::Type * type, const ast::TypeEnvironment & env, const ast::SymbolTable & symtab );
+
         // in CastCost.cc
-        Cost castCost( Type *src, Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env );
+        Cost castCost( const Type * src, const Type * dest, bool srcIsLvalue,
+                const SymTab::Indexer & indexer, const TypeEnvironment & env );
+        Cost castCost(
+                const ast::Type * src, const ast::Type * dst, const ast::SymbolTable & symtab,
+                const ast::TypeEnvironment & env );
 
         // in ConversionCost.cc
-        Cost conversionCost( Type *src, Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env );
+        Cost conversionCost( const Type * src, const Type * dest, bool srcIsLvalue,
+                const SymTab::Indexer & indexer, const TypeEnvironment & env );
+        Cost conversionCost(
+                const ast::Type * src, const ast::Type * dst, const ast::SymbolTable & symtab,
+                const ast::TypeEnvironment & env );
+
+        // in AlternativeFinder.cc
+        Cost computeConversionCost( Type * actualType, Type * formalType, bool actualIsLvalue,
+                const SymTab::Indexer & indexer, const TypeEnvironment & env );
 
         // in PtrsAssignable.cc
-        int ptrsAssignable( Type *src, Type *dest, const TypeEnvironment &env );
+        int ptrsAssignable( const Type * src, const Type * dest, const TypeEnvironment & env );
+        int ptrsAssignable( const ast::Type * src, const ast::Type * dst,
+                const ast::TypeEnvironment & env );
 
         // in PtrsCastable.cc
-        int ptrsCastable( Type *src, Type *dest, const TypeEnvironment &env, const SymTab::Indexer &indexer );
+        int ptrsCastable( const Type * src, const Type * dest, const TypeEnvironment & env, const SymTab::Indexer & indexer );
+        int ptrsCastable(
+                const ast::Type * src, const ast::Type * dst, const ast::SymbolTable & symtab,
+                const ast::TypeEnvironment & env );
 
         // in Unify.cc
-        bool isFtype( Type *type );
-        bool typesCompatible( Type *, Type *, const SymTab::Indexer &indexer, const TypeEnvironment &env );
-        bool typesCompatibleIgnoreQualifiers( Type *, Type *, const SymTab::Indexer &indexer, const TypeEnvironment &env );
-
-        inline bool typesCompatible( Type *t1, Type *t2, const SymTab::Indexer &indexer ) {
+        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 );
+
+        inline bool typesCompatible( const Type * t1, const Type * t2, const SymTab::Indexer & indexer ) {
                 TypeEnvironment env;
                 return typesCompatible( t1, t2, indexer, env );
         }
 
-        inline bool typesCompatibleIgnoreQualifiers( Type *t1, Type *t2, const SymTab::Indexer &indexer ) {
+        inline bool typesCompatibleIgnoreQualifiers( const Type * t1, const Type * t2, const SymTab::Indexer & indexer ) {
                 TypeEnvironment env;
                 return typesCompatibleIgnoreQualifiers( t1, t2, indexer, env );
         }
 
+        bool typesCompatible(
+                const ast::Type *, const ast::Type *, const ast::SymbolTable & symtab = {},
+                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 );
+        /// Creates or extracts the type represented by the list of returns in a `FunctionType`.
+        ast::ptr<ast::Type> extractResultType( const ast::FunctionType * func );
 
         // in CommonType.cc
-        Type *commonType( Type *type1, Type *type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars );
+        Type * commonType( Type * type1, Type * type2, bool widenFirst, bool widenSecond, const SymTab::Indexer & indexer, TypeEnvironment & env, const OpenVarSet & openVars );
+        ast::ptr< ast::Type > commonType(
+                const ast::ptr< ast::Type > & type1, const ast::ptr< ast::Type > & type2, WidenMode widen,
+                const ast::SymbolTable & symtab, ast::TypeEnvironment & env, const ast::OpenVarSet & open );
 
         // in PolyCost.cc
-        int polyCost( Type *type, const TypeEnvironment &env, const SymTab::Indexer &indexer );
+        int polyCost( Type * type, const TypeEnvironment & env, const SymTab::Indexer & indexer );
+        int polyCost(
+                const ast::Type * type, const ast::SymbolTable & symtab, const ast::TypeEnvironment & env );
+
+        // in SpecCost.cc
+        int specCost( Type * type );
+        int specCost( const ast::Type * type );
 
         // in Occurs.cc
-        bool occurs( Type *type, std::string varName, const TypeEnvironment &env );
+        bool occurs( const Type * type, const std::string & varName, const TypeEnvironment & env );
+        // new AST version in TypeEnvironment.cpp (only place it was used in old AST)
+
+        template<typename Iter>
+        bool occursIn( Type* ty, Iter begin, Iter end, const TypeEnvironment & env ) {
+                while ( begin != end ) {
+                        if ( occurs( ty, *begin, env ) ) return true;
+                        ++begin;
+                }
+                return false;
+        }
 
         // in AlternativeFinder.cc
         void referenceToRvalueConversion( Expression *& expr, Cost & cost );
-
-        // flatten tuple type into list of types
+        // in CandidateFinder.cpp
+        const ast::Expr * referenceToRvalueConversion( const ast::Expr * expr, Cost & cost );
+
+        /// flatten tuple type into list of types
         template< typename OutputIterator >
         void flatten( Type * type, OutputIterator out ) {
@@ -119 +179 @@
                 }
         }
+
+        /// flatten tuple type into existing list of types
+        static inline void flatten(
+                const ast::Type * type, std::vector< ast::ptr< ast::Type > > & out
+        ) {
+                if ( auto tupleType = dynamic_cast< const ast::TupleType * >( type ) ) {
+                        for ( const ast::Type * t : tupleType->types ) {
+                                flatten( t, out );
+                        }
+                } else {
+                        out.emplace_back( type );
+                }
+        }
+
+        /// flatten tuple type into list of types
+        static inline std::vector< ast::ptr< ast::Type > > flatten( const ast::Type * type ) {
+                std::vector< ast::ptr< ast::Type > > out;
+                out.reserve( type->size() );
+                flatten( type, out );
+                return out;
+        }
+
+        // in TypeEnvironment.cc
+        bool isFtype( const Type * type );
 } // namespace ResolvExpr
+
+namespace ast {
+        // in TypeEnvironment.cpp
+        bool isFtype( const ast::Type * type );
+} // namespace ast
 
 // Local Variables: //