source: src/AST/Type.cpp @ 93c10de

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

Minimal changes to pull out nested types, TypeInstType::TypeEnvKey? and TypeDecl::Data (now TypeData?) from there parent types. Although they do connect to the parent types they were nested in they are used on their own most of the time.

  • Property mode set to 100644
File size: 6.6 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// Type.cpp --
8//
9// Author           : Aaron B. Moss
10// Created On       : Mon May 13 15:00:00 2019
11// Last Modified By : Andrew Beach
12// Last Modified On : Thu Nov 24  9:49:00 2022
13// Update Count     : 6
14//
15
16#include "Type.hpp"
17
18#include <cassert>
19#include <utility>               // for move
20#include <vector>
21
22#include "Decl.hpp"
23#include "Init.hpp"
24#include "Inspect.hpp"
25#include "Common/utility.h"      // for copy, move
26#include "Tuples/Tuples.h"       // for isTtype
27
28namespace ast {
29
30const Type * Type::getComponent( unsigned i ) const {
31        assertf( size() == 1 && i == 0, "Type::getComponent was called with size %d and index %d\n", size(), i );
32        return this;
33}
34
35const Type * Type::stripDeclarator() const {
36        const Type * t;
37        const Type * a;
38        for ( t = this; (a = ast::getPointerBase( t )); t = a );
39        return t;
40}
41
42const Type * Type::stripReferences() const {
43        const Type * t;
44        const ReferenceType * r;
45        for ( t = this; (r = dynamic_cast<const ReferenceType *>(t) ); t = r->base );
46        return t;
47}
48
49// --- BasicType
50
51// GENERATED START, DO NOT EDIT
52// GENERATED BY BasicTypes-gen.cc
53const char * BasicType::typeNames[] = {
54        "_Bool",
55        "char",
56        "signed char",
57        "unsigned char",
58        "signed short int",
59        "unsigned short int",
60        "signed int",
61        "unsigned int",
62        "signed long int",
63        "unsigned long int",
64        "signed long long int",
65        "unsigned long long int",
66        "__int128",
67        "unsigned __int128",
68        "_Float16",
69        "_Float16 _Complex",
70        "_Float32",
71        "_Float32 _Complex",
72        "float",
73        "float _Complex",
74        "_Float32x",
75        "_Float32x _Complex",
76        "_Float64",
77        "_Float64 _Complex",
78        "double",
79        "double _Complex",
80        "_Float64x",
81        "_Float64x _Complex",
82        "__float80",
83        "_Float128",
84        "_Float128 _Complex",
85        "__float128",
86        "long double",
87        "long double _Complex",
88        "_Float128x",
89        "_Float128x _Complex",
90};
91// GENERATED END
92
93// --- FunctionType
94namespace {
95        bool containsTtype( const std::vector<ptr<Type>> & l ) {
96                if ( ! l.empty() ) {
97                        return Tuples::isTtype( l.back() );
98                }
99                return false;
100        }
101}
102
103bool FunctionType::isTtype() const {
104        return containsTtype( returns ) || containsTtype( params );
105}
106
107// --- BaseInstType
108
109std::vector<readonly<Decl>> BaseInstType::lookup( const std::string& name ) const {
110        assertf( aggr(), "Must have aggregate to perform lookup" );
111
112        std::vector<readonly<Decl>> found;
113        for ( const Decl * decl : aggr()->members ) {
114                if ( decl->name == name ) { found.emplace_back( decl ); }
115        }
116        return found;
117}
118
119// --- SueInstType (StructInstType, UnionInstType, EnumInstType)
120
121template<typename decl_t>
122SueInstType<decl_t>::SueInstType(
123        const base_type * b, CV::Qualifiers q, std::vector<ptr<Attribute>>&& as )
124: BaseInstType( b->name, q, std::move(as) ), base( b ) {}
125
126template<typename decl_t>
127SueInstType<decl_t>::SueInstType(
128        const base_type * b, std::vector<ptr<Expr>> && params,
129        CV::Qualifiers q, std::vector<ptr<Attribute>> && as )
130: BaseInstType( b->name, std::move(params), q, std::move(as) ), base( b ) {}
131
132template<typename decl_t>
133bool SueInstType<decl_t>::isComplete() const {
134        return base ? base->body : false;
135}
136
137template class SueInstType<StructDecl>;
138template class SueInstType<UnionDecl>;
139template class SueInstType<EnumDecl>;
140
141// --- TraitInstType
142
143TraitInstType::TraitInstType(
144        const TraitDecl * b, CV::Qualifiers q, std::vector<ptr<Attribute>>&& as )
145: BaseInstType( b->name, q, std::move(as) ), base( b ) {}
146
147// --- TypeInstType
148
149TypeInstType::TypeInstType( const TypeEnvKey & key )
150: BaseInstType(key.base->name), base(key.base), kind(key.base->kind), formal_usage(key.formal_usage), expr_id(key.expr_id) {}
151
152bool TypeInstType::operator==( const TypeInstType & other ) const {
153        return base == other.base
154                && formal_usage == other.formal_usage
155                && expr_id == other.expr_id;
156}
157
158TypeInstType::TypeInstType( const TypeDecl * b,
159        CV::Qualifiers q, std::vector<ptr<Attribute>> && as )
160: BaseInstType( b->name, q, std::move(as) ), base( b ), kind( b->kind ) {}
161
162void TypeInstType::set_base( const TypeDecl * b ) {
163        base = b;
164        kind = b->kind;
165}
166
167bool TypeInstType::isComplete() const { return base->sized; }
168
169std::string TypeEnvKey::typeString() const {
170        return std::string("_") + std::to_string(formal_usage)
171                + "_" + std::to_string(expr_id) + "_" + base->name;
172}
173
174bool TypeEnvKey::operator==(
175                const TypeEnvKey & other ) const {
176        return base == other.base
177                && formal_usage == other.formal_usage
178                && expr_id == other.expr_id;
179}
180
181bool TypeEnvKey::operator<(
182                const TypeEnvKey & other ) const {
183        // TypeEnvKey ordering is an arbitrary total ordering.
184        // It doesn't mean anything but allows for a sorting.
185        if ( base < other.base ) {
186                return true;
187        } else if ( other.base < base ) {
188                return false;
189        } else if ( formal_usage < other.formal_usage ) {
190                return true;
191        } else if ( other.formal_usage < formal_usage ) {
192                return false;
193        } else {
194                return expr_id < other.expr_id;
195        }
196}
197
198// --- TupleType
199
200TupleType::TupleType( std::vector<ptr<Type>> && ts, CV::Qualifiers q )
201: Type( q ), types( std::move(ts) ), members() {
202        // This constructor is awkward. `TupleType` needs to contain objects so that members can be
203        // named, but members without initializer nodes end up getting constructors, which breaks
204        // things. This happens because the object decls have to be visited so that their types are
205        // kept in sync with the types listed here. Ultimately, the types listed here should perhaps
206        // be eliminated and replaced with a list-view over members. The temporary solution is to
207        // make a `ListInit` with `maybeConstructed = false`, so when the object is visited it is not
208        // constructed. Potential better solutions include:
209        //   a) Separate `TupleType` from its declarations, into `TupleDecl` and `Tuple{Inst?}Type`,
210        //      similar to the aggregate types.
211        //   b) Separate initializer nodes better, e.g. add a `MaybeConstructed` node that is replaced
212        //      by `genInit`, rather than the current boolean flag.
213        members.reserve( types.size() );
214        for ( const Type * ty : types ) {
215                members.emplace_back( new ObjectDecl{
216                        CodeLocation(), "", ty, new ListInit( CodeLocation(), {}, {}, NoConstruct ),
217                        Storage::Classes{}, Linkage::Cforall } );
218        }
219}
220
221bool isUnboundType(const Type * type) {
222        if (auto typeInst = dynamic_cast<const TypeInstType *>(type)) {
223                // xxx - look for a type name produced by renameTyVars.
224
225                // TODO: once TypeInstType representation is updated, it should properly check
226                // if the context id is filled. this is a temporary hack for now
227                return typeInst->formal_usage > 0;
228        }
229        return false;
230}
231
232}
233
234// Local Variables: //
235// tab-width: 4 //
236// mode: c++ //
237// compile-command: "make install" //
238// End: //
Note: See TracBrowser for help on using the repository browser.