source: src/ResolvExpr/typeops.h @ 7870799

arm-ehenumforall-pointer-decayjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-exprpthread-emulationqualifiedEnum
Last change on this file since 7870799 was 7870799, checked in by Thierry Delisle <tdelisle@…>, 3 years ago

Cast cost and conversion cost now take constant parameters.
This required supporting visiting const node.
The PassVisitor? can now visit const nodes but not when using the Indexer

  • 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 : Peter A. Buhr
12// Last Modified On : Fri Feb  8 09:30:34 2019
13// Update Count     : 4
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#include "SymTab/Indexer.h"
31
32namespace ResolvExpr {
33        // combos: takes a list of sets and returns a set of lists representing every possible way of forming a list by
34        // picking one element out of each set
35        template< typename InputIterator, typename OutputIterator >
36        void combos( InputIterator begin, InputIterator end, OutputIterator out ) {
37                typedef typename InputIterator::value_type SetType;
38                typedef typename std::vector< typename SetType::value_type > ListType;
39
40                if ( begin == end )     {
41                        *out++ = ListType();
42                        return;
43                } // if
44
45                InputIterator current = begin;
46                begin++;
47
48                std::vector< ListType > recursiveResult;
49                combos( begin, end, back_inserter( recursiveResult ) );
50
51                for ( const auto& i : recursiveResult ) for ( const auto& j : *current ) {
52                        ListType result;
53                        std::back_insert_iterator< ListType > inserter = back_inserter( result );
54                        *inserter++ = j;
55                        std::copy( i.begin(), i.end(), inserter );
56                        *out++ = result;
57                }
58        }
59
60        // in AdjustExprType.cc
61        /// Replaces array types with the equivalent pointer, and function types with a pointer-to-function
62        void adjustExprType( Type *&type, const TypeEnvironment &env, const SymTab::Indexer &indexer );
63
64        /// Replaces array types with the equivalent pointer, and function types with a pointer-to-function using empty TypeEnvironment and Indexer
65        void adjustExprType( Type *& type );
66
67        template< typename ForwardIterator >
68        void adjustExprTypeList( ForwardIterator begin, ForwardIterator end, const TypeEnvironment &env, const SymTab::Indexer &indexer ) {
69                while ( begin != end ) {
70                        adjustExprType( *begin++, env, indexer );
71                } // while
72        }
73
74        /// Replaces array types with equivalent pointer, and function types with a pointer-to-function
75        const ast::Type * adjustExprType(
76                const ast::Type * type, const ast::TypeEnvironment & env, const ast::SymbolTable & symtab );
77
78        // in CastCost.cc
79        Cost castCost( const Type * src, const Type * dest, const SymTab::Indexer &indexer, const TypeEnvironment &env );
80        Cost castCost(
81                const ast::Type * src, const ast::Type * dst, const ast::SymbolTable & symtab,
82                const ast::TypeEnvironment & env );
83
84        // in ConversionCost.cc
85        Cost conversionCost( const Type *src, const Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env );
86        Cost conversionCost(
87                const ast::Type * src, const ast::Type * dst, const ast::SymbolTable & symtab,
88                const ast::TypeEnvironment & env );
89
90        // in AlternativeFinder.cc
91        Cost computeConversionCost( Type *actualType, Type *formalType,
92                const SymTab::Indexer &indexer, const TypeEnvironment &env );
93
94        // in PtrsAssignable.cc
95        int ptrsAssignable( const Type * src, const Type * dest, const TypeEnvironment &env );
96        int ptrsAssignable( const ast::Type * src, const ast::Type * dst,
97                const ast::TypeEnvironment & env );
98
99        // in PtrsCastable.cc
100        int ptrsCastable( const Type * src, const Type * dest, const TypeEnvironment &env, const SymTab::Indexer &indexer );
101        int ptrsCastable(
102                const ast::Type * src, const ast::Type * dst, const ast::SymbolTable & symtab,
103                const ast::TypeEnvironment & env );
104
105        // in Unify.cc
106        bool typesCompatible( Type *, Type *, const SymTab::Indexer &indexer, const TypeEnvironment &env );
107        bool typesCompatibleIgnoreQualifiers( const Type *, const Type *, const SymTab::Indexer &indexer, const TypeEnvironment &env );
108
109        inline bool typesCompatible( Type *t1, Type *t2, const SymTab::Indexer &indexer ) {
110                TypeEnvironment env;
111                return typesCompatible( t1, t2, indexer, env );
112        }
113
114        inline bool typesCompatibleIgnoreQualifiers( const Type * t1, const Type * t2, const SymTab::Indexer &indexer ) {
115                TypeEnvironment env;
116                return typesCompatibleIgnoreQualifiers( t1, t2, indexer, env );
117        }
118
119        bool typesCompatible(
120                const ast::Type *, const ast::Type *, const ast::SymbolTable & symtab = {},
121                const ast::TypeEnvironment & env = {} );
122
123        bool typesCompatibleIgnoreQualifiers(
124                const ast::Type *, const ast::Type *, const ast::SymbolTable &,
125                const ast::TypeEnvironment & env = {} );
126
127        /// creates the type represented by the list of returnVals in a FunctionType. The caller owns the return value.
128        Type * extractResultType( FunctionType * functionType );
129        /// Creates or extracts the type represented by the list of returns in a `FunctionType`.
130        ast::ptr<ast::Type> extractResultType( const ast::FunctionType * func );
131
132        // in CommonType.cc
133        Type * commonType( Type *type1, Type *type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars );
134        ast::ptr< ast::Type > commonType(
135                const ast::ptr< ast::Type > & type1, const ast::ptr< ast::Type > & type2, WidenMode widen,
136                const ast::SymbolTable & symtab, ast::TypeEnvironment & env, const ast::OpenVarSet & open );
137
138        // in PolyCost.cc
139        int polyCost( Type *type, const TypeEnvironment &env, const SymTab::Indexer &indexer );
140        int polyCost(
141                const ast::Type * type, const ast::SymbolTable & symtab, const ast::TypeEnvironment & env );
142
143        // in SpecCost.cc
144        int specCost( Type *type );
145        int specCost( const ast::Type * type );
146
147        // in Occurs.cc
148        bool occurs( Type *type, std::string varName, const TypeEnvironment &env );
149        // new AST version in TypeEnvironment.cpp (only place it was used in old AST)
150
151        template<typename Iter>
152        bool occursIn( Type* ty, Iter begin, Iter end, const TypeEnvironment &env ) {
153                while ( begin != end ) {
154                        if ( occurs( ty, *begin, env ) ) return true;
155                        ++begin;
156                }
157                return false;
158        }
159
160        // in AlternativeFinder.cc
161        void referenceToRvalueConversion( Expression *& expr, Cost & cost );
162        // in CandidateFinder.cpp
163        const ast::Expr * referenceToRvalueConversion( const ast::Expr * expr, Cost & cost );
164
165        /// flatten tuple type into list of types
166        template< typename OutputIterator >
167        void flatten( Type * type, OutputIterator out ) {
168                if ( TupleType * tupleType = dynamic_cast< TupleType * >( type ) ) {
169                        for ( Type * t : tupleType->get_types() ) {
170                                flatten( t, out );
171                        }
172                } else {
173                        *out++ = type->clone();
174                }
175        }
176
177        /// flatten tuple type into existing list of types
178        static inline void flatten(
179                const ast::Type * type, std::vector< ast::ptr< ast::Type > > & out
180        ) {
181                if ( auto tupleType = dynamic_cast< const ast::TupleType * >( type ) ) {
182                        for ( const ast::Type * t : tupleType->types ) {
183                                flatten( t, out );
184                        }
185                } else {
186                        out.emplace_back( type );
187                }
188        }
189
190        /// flatten tuple type into list of types
191        static inline std::vector< ast::ptr< ast::Type > > flatten( const ast::Type * type ) {
192                std::vector< ast::ptr< ast::Type > > out;
193                out.reserve( type->size() );
194                flatten( type, out );
195                return out;
196        }
197
198        // in TypeEnvironment.cc
199        bool isFtype( Type *type );
200} // namespace ResolvExpr
201
202namespace ast {
203        // in TypeEnvironment.cpp
204        bool isFtype( const ast::Type * type );
205} // namespace ast
206
207// Local Variables: //
208// tab-width: 4 //
209// mode: c++ //
210// compile-command: "make install" //
211// End: //
Note: See TracBrowser for help on using the repository browser.