source: src/ResolvExpr/typeops.h @ e563edf

ADTast-experimental
Last change on this file since e563edf was e563edf, checked in by Andrew Beach <ajbeach@…>, 14 months ago

Header Clean-up: Clearing out typeops, moving things to Unify because that header already exist.

  • Property mode set to 100644
File size: 7.4 KB
Line 
1//
2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
3//
4// The contents of this file are covered under the licence agreement in the
5// file "LICENCE" distributed with Cforall.
6//
7// typeops.h --
8//
9// Author           : Richard C. Bilson
10// Created On       : Sun May 17 07:28:22 2015
11// Last Modified By : Andrew Beach
12// Last Modified On : Tue Oct  1 09:45:00 2019
13// Update Count     : 6
14//
15
16#pragma once
17
18#include <vector>
19
20#include "Cost.h"
21#include "TypeEnvironment.h"
22#include "WidenMode.h"
23#include "AST/Fwd.hpp"
24#include "AST/Node.hpp"
25#include "AST/SymbolTable.hpp"
26#include "AST/Type.hpp"
27#include "AST/TypeEnvironment.hpp"
28#include "SynTree/SynTree.h"
29#include "SynTree/Type.h"
30
31namespace SymTab {
32        class Indexer;
33}
34
35namespace ResolvExpr {
36        // combos: takes a list of sets and returns a set of lists representing every possible way of forming a list by
37        // picking one element out of each set
38        template< typename InputIterator, typename OutputIterator >
39        void combos( InputIterator begin, InputIterator end, OutputIterator out ) {
40                typedef typename InputIterator::value_type SetType;
41                typedef typename std::vector< typename SetType::value_type > ListType;
42
43                if ( begin == end )     {
44                        *out++ = ListType();
45                        return;
46                } // if
47
48                InputIterator current = begin;
49                begin++;
50
51                std::vector< ListType > recursiveResult;
52                combos( begin, end, back_inserter( recursiveResult ) );
53
54                for ( const auto& i : recursiveResult ) for ( const auto& j : *current ) {
55                        ListType result;
56                        std::back_insert_iterator< ListType > inserter = back_inserter( result );
57                        *inserter++ = j;
58                        std::copy( i.begin(), i.end(), inserter );
59                        *out++ = result;
60                }
61        }
62
63        // in AdjustExprType.cc
64        /// Replaces array types with the equivalent pointer, and function types with a pointer-to-function
65        void adjustExprType( Type *& type, const TypeEnvironment & env, const SymTab::Indexer & indexer );
66
67        /// Replaces array types with the equivalent pointer, and function types with a pointer-to-function using empty TypeEnvironment and Indexer
68        void adjustExprType( Type *& type );
69
70        template< typename ForwardIterator >
71        void adjustExprTypeList( ForwardIterator begin, ForwardIterator end, const TypeEnvironment & env, const SymTab::Indexer & indexer ) {
72                while ( begin != end ) {
73                        adjustExprType( *begin++, env, indexer );
74                } // while
75        }
76
77        /// Replaces array types with equivalent pointer, and function types with a pointer-to-function
78        const ast::Type * adjustExprType(
79                const ast::Type * type, const ast::TypeEnvironment & env, const ast::SymbolTable & symtab );
80
81        // in CastCost.cc
82        Cost castCost( const Type * src, const Type * dest, bool srcIsLvalue,
83                const SymTab::Indexer & indexer, const TypeEnvironment & env );
84        Cost castCost(
85                const ast::Type * src, const ast::Type * dst, bool srcIsLvalue,
86                const ast::SymbolTable & symtab, const ast::TypeEnvironment & env );
87
88        // in ConversionCost.cc
89        Cost conversionCost( const Type * src, const Type * dest, bool srcIsLvalue,
90                const SymTab::Indexer & indexer, const TypeEnvironment & env );
91        Cost conversionCost(
92                const ast::Type * src, const ast::Type * dst, bool srcIsLvalue,
93                const ast::SymbolTable & symtab, const ast::TypeEnvironment & env );
94
95        // in AlternativeFinder.cc
96        Cost computeConversionCost( Type * actualType, Type * formalType, bool actualIsLvalue,
97                const SymTab::Indexer & indexer, const TypeEnvironment & env );
98
99        // in PtrsAssignable.cc
100        int ptrsAssignable( const Type * src, const Type * dest, const TypeEnvironment & env );
101        int ptrsAssignable( const ast::Type * src, const ast::Type * dst,
102                const ast::TypeEnvironment & env );
103
104        // in PtrsCastable.cc
105        int ptrsCastable( const Type * src, const Type * dest, const TypeEnvironment & env, const SymTab::Indexer & indexer );
106        int ptrsCastable(
107                const ast::Type * src, const ast::Type * dst, const ast::SymbolTable & symtab,
108                const ast::TypeEnvironment & env );
109
110        /// creates the type represented by the list of returnVals in a FunctionType. The caller owns the return value.
111        Type * extractResultType( FunctionType * functionType );
112        /// Creates or extracts the type represented by the list of returns in a `FunctionType`.
113        ast::ptr<ast::Type> extractResultType( const ast::FunctionType * func );
114
115        // in CommonType.cc
116        Type * commonType( Type * type1, Type * type2, bool widenFirst, bool widenSecond, const SymTab::Indexer & indexer, TypeEnvironment & env, const OpenVarSet & openVars );
117        ast::ptr< ast::Type > commonType(
118                const ast::ptr< ast::Type > & type1, const ast::ptr< ast::Type > & type2,
119                        ast::TypeEnvironment & env, ast::AssertionSet & need, ast::AssertionSet & have,
120                        const ast::OpenVarSet & open, WidenMode widen, const ast::SymbolTable & symtab
121        );
122        // in Unify.cc
123        std::vector< ast::ptr< ast::Type > > flattenList(
124                const std::vector< ast::ptr< ast::Type > > & src, ast::TypeEnvironment & env
125        );
126
127        // in PolyCost.cc
128        int polyCost( Type * type, const TypeEnvironment & env, const SymTab::Indexer & indexer );
129        int polyCost(
130                const ast::Type * type, const ast::SymbolTable & symtab, const ast::TypeEnvironment & env );
131
132        // in SpecCost.cc
133        int specCost( Type * type );
134        int specCost( const ast::Type * type );
135
136        // in Occurs.cc
137        bool occurs( const Type * type, const std::string & varName, const TypeEnvironment & env );
138        // new AST version in TypeEnvironment.cpp (only place it was used in old AST)
139
140        template<typename Iter>
141        bool occursIn( Type* ty, Iter begin, Iter end, const TypeEnvironment & env ) {
142                while ( begin != end ) {
143                        if ( occurs( ty, *begin, env ) ) return true;
144                        ++begin;
145                }
146                return false;
147        }
148
149        // in AlternativeFinder.cc
150        void referenceToRvalueConversion( Expression *& expr, Cost & cost );
151        // in CandidateFinder.cpp
152        const ast::Expr * referenceToRvalueConversion( const ast::Expr * expr, Cost & cost );
153
154        /// flatten tuple type into list of types
155        template< typename OutputIterator >
156        void flatten( Type * type, OutputIterator out ) {
157                if ( TupleType * tupleType = dynamic_cast< TupleType * >( type ) ) {
158                        for ( Type * t : tupleType->get_types() ) {
159                                flatten( t, out );
160                        }
161                } else {
162                        *out++ = type->clone();
163                }
164        }
165
166        /// flatten tuple type into existing list of types
167        inline void flatten(
168                const ast::Type * type, std::vector< ast::ptr< ast::Type > > & out
169        ) {
170                if ( auto tupleType = dynamic_cast< const ast::TupleType * >( type ) ) {
171                        for ( const ast::Type * t : tupleType->types ) {
172                                flatten( t, out );
173                        }
174                } else {
175                        out.emplace_back( type );
176                }
177        }
178
179        /// flatten tuple type into list of types
180        inline std::vector< ast::ptr< ast::Type > > flatten( const ast::Type * type ) {
181                std::vector< ast::ptr< ast::Type > > out;
182                out.reserve( type->size() );
183                flatten( type, out );
184                return out;
185        }
186
187        template< typename Iter >
188        const ast::Type * tupleFromTypes( Iter crnt, Iter end ) {
189                std::vector< ast::ptr< ast::Type > > types;
190                while ( crnt != end ) {
191                        // it is guaranteed that a ttype variable will be bound to a flat tuple, so ensure
192                        // that this results in a flat tuple
193                        flatten( *crnt, types );
194
195                        ++crnt;
196                }
197
198
199                return new ast::TupleType{ std::move(types) };
200        }
201
202        inline const ast::Type * tupleFromTypes(
203                const std::vector< ast::ptr< ast::Type > > & tys
204        ) {
205                return tupleFromTypes( tys.begin(), tys.end() );
206        }
207
208       
209
210        // in TypeEnvironment.cc
211        bool isFtype( const Type * type );
212} // namespace ResolvExpr
213
214namespace ast {
215        // in TypeEnvironment.cpp
216        bool isFtype( const ast::Type * type );
217} // namespace ast
218
219// Local Variables: //
220// tab-width: 4 //
221// mode: c++ //
222// compile-command: "make install" //
223// End: //
Note: See TracBrowser for help on using the repository browser.