source: src/AST/Decl.hpp

Last change on this file was 544deb9, checked in by JiadaL <j82liang@…>, 6 weeks ago

Update ReplacePseudoFunc?, mostly the runtime lookup for attribute pseudo-function. It is imcomplete and returning dummy value

  • Property mode set to 100644
File size: 14.9 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// Decl.hpp --
8//
9// Author           : Aaron B. Moss
10// Created On       : Thu May 9 10:00:00 2019
11// Last Modified By : Andrew Beach
12// Last Modified On : Wed Apr  5 10:42:00 2023
13// Update Count     : 35
14//
15
16#pragma once
17
18#include <iosfwd>
19#include <string>              // for string, to_string
20#include <unordered_map>
21#include <vector>
22#include <algorithm>
23
24#include "FunctionSpec.hpp"
25#include "Fwd.hpp"             // for UniqueId
26#include "LinkageSpec.hpp"
27#include "Node.hpp"            // for ptr, readonly
28#include "ParseNode.hpp"
29#include "StorageClasses.hpp"
30#include "Visitor.hpp"
31
32// Must be included in *all* AST classes; should be #undef'd at the end of the file
33#define MUTATE_FRIEND \
34        template<typename node_t> friend node_t * mutate(const node_t * node); \
35        template<typename node_t> friend node_t * shallowCopy(const node_t * node);
36
37namespace ast {
38
39/// Base declaration class
40class Decl : public ParseNode {
41public:
42        std::string name;
43        Storage::Classes storage;
44        Linkage::Spec linkage;
45        UniqueId uniqueId = 0;
46        bool extension = false;
47
48        Decl( const CodeLocation& loc, const std::string& name, Storage::Classes storage,
49                Linkage::Spec linkage )
50        : ParseNode( loc ), name( name ), storage( storage ), linkage( linkage ) {}
51
52        Decl* set_extension( bool ex ) { extension = ex; return this; }
53
54        /// Ensures this node has a unique ID
55        void fixUniqueId();
56
57        const Decl * accept( Visitor & v ) const override = 0;
58private:
59        Decl * clone() const override = 0;
60        MUTATE_FRIEND
61};
62
63/// Typed declaration base class
64class DeclWithType : public Decl {
65public:
66        /// Represents the type with all types and typedefs expanded.
67        std::string mangleName;
68        /// Stores the scope level at which the variable was declared.
69        /// Used to access shadowed identifiers.
70        int scopeLevel = 0;
71
72        std::vector<ptr<Attribute>> attributes;
73        Function::Specs funcSpec;
74        ptr<Expr> asmName;
75        bool isDeleted = false;
76        bool isTypeFixed = false;
77
78        DeclWithType( const CodeLocation& loc, const std::string& name, Storage::Classes storage,
79                Linkage::Spec linkage, std::vector<ptr<Attribute>>&& attrs, Function::Specs fs )
80        : Decl( loc, name, storage, linkage ), mangleName(), attributes( std::move(attrs) ),
81                funcSpec(fs), asmName() {}
82
83        std::string scopedMangleName() const { return mangleName + "_" + std::to_string(scopeLevel); }
84
85        /// Get type of this declaration. May be generated by subclass
86        virtual const Type * get_type() const = 0;
87        /// Set type of this declaration. May be verified by subclass
88        virtual void set_type( const Type * ) = 0;
89
90        const DeclWithType * accept( Visitor & v ) const override = 0;
91private:
92        DeclWithType * clone() const override = 0;
93        MUTATE_FRIEND
94};
95
96/// Object declaration `Foo foo = 42;`
97class ObjectDecl final : public DeclWithType {
98public:
99        ptr<Type> type;
100        ptr<Init> init;
101        ptr<Expr> bitfieldWidth;
102
103        ObjectDecl( const CodeLocation & loc, const std::string & name, const Type * type,
104                const Init * init = nullptr, Storage::Classes storage = {},
105                Linkage::Spec linkage = Linkage::Cforall, const Expr * bitWd = nullptr,
106                std::vector< ptr<Attribute> > && attrs = {}, Function::Specs fs = {} )
107        : DeclWithType( loc, name, storage, linkage, std::move(attrs), fs ), type( type ),
108          init( init ), bitfieldWidth( bitWd ) {}
109
110        const Type* get_type() const override { return type; }
111        void set_type( const Type * ty ) override { type = ty; }
112
113        const DeclWithType * accept( Visitor& v ) const override { return v.visit( this ); }
114private:
115        ObjectDecl * clone() const override { return new ObjectDecl{ *this }; }
116        MUTATE_FRIEND
117};
118
119/// Function variable arguments flag
120enum ArgumentFlag { FixedArgs, VariableArgs };
121
122/// Object declaration `int foo()`
123class FunctionDecl final : public DeclWithType {
124public:
125        std::vector<ptr<TypeDecl>> type_params;
126        std::vector<ptr<DeclWithType>> assertions;
127        std::vector<ptr<DeclWithType>> params;
128        std::vector<ptr<DeclWithType>> returns;
129        // declared type, derived from parameter declarations
130        ptr<FunctionType> type;
131        /// Null for the forward declaration of a function.
132        ptr<CompoundStmt> stmts;
133        std::vector< ptr<Expr> > withExprs;
134
135        /// Monomorphic Function Constructor:
136        FunctionDecl( const CodeLocation & locaction, const std::string & name,
137                std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,
138                CompoundStmt * stmts, Storage::Classes storage = {}, Linkage::Spec linkage = Linkage::Cforall,
139                std::vector<ptr<Attribute>>&& attrs = {}, Function::Specs fs = {}, ArgumentFlag isVarArgs = FixedArgs );
140
141        /// Polymorphic Function Constructor:
142        FunctionDecl( const CodeLocation & location, const std::string & name,
143                std::vector<ptr<TypeDecl>>&& forall, std::vector<ptr<DeclWithType>>&& assertions,
144                std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,
145                CompoundStmt * stmts, Storage::Classes storage = {}, Linkage::Spec linkage = Linkage::Cforall,
146                std::vector<ptr<Attribute>>&& attrs = {}, Function::Specs fs = {}, ArgumentFlag isVarArgs = FixedArgs );
147
148        const Type * get_type() const override;
149        void set_type( const Type * t ) override;
150
151        bool has_body() const { return stmts; }
152
153        const DeclWithType * accept( Visitor & v ) const override { return v.visit( this ); }
154private:
155        FunctionDecl * clone() const override { return new FunctionDecl( *this ); }
156        MUTATE_FRIEND
157};
158
159/// Base class for named type aliases
160class NamedTypeDecl : public Decl {
161public:
162        ptr<Type> base;
163        std::vector<ptr<DeclWithType>> assertions;
164
165        NamedTypeDecl(
166                const CodeLocation & loc, const std::string & name, Storage::Classes storage,
167                const Type * b, Linkage::Spec spec = Linkage::Cforall )
168        : Decl( loc, name, storage, spec ), base( b ), assertions() {}
169
170        /// Produces a name for the kind of alias
171        virtual const char * typeString() const = 0;
172
173private:
174        NamedTypeDecl* clone() const override = 0;
175        MUTATE_FRIEND
176};
177
178/// Cforall type variable: `dtype T`
179class TypeDecl final : public NamedTypeDecl {
180  public:
181        enum Kind { Dtype, DStype, Otype, Ftype, Ttype, Dimension, NUMBER_OF_KINDS };
182
183        Kind kind;
184        bool sized;
185        ptr<Type> init;
186
187        TypeDecl(
188                const CodeLocation & loc, const std::string & name, Storage::Classes storage,
189                const Type * b, TypeDecl::Kind k, bool s, const Type * i = nullptr )
190        : NamedTypeDecl( loc, name, storage, b ), kind( k ), sized( k == TypeDecl::Ttype || s ),
191          init( i ) {}
192
193        const char * typeString() const override;
194        /// Produces a name for generated code
195        const char * genTypeString() const;
196
197        /// convenience accessor to match Type::isComplete()
198        bool isComplete() const { return sized; }
199
200        const Decl * accept( Visitor & v ) const override { return v.visit( this ); }
201  private:
202        TypeDecl * clone() const override { return new TypeDecl{ *this }; }
203        MUTATE_FRIEND
204};
205
206/// Data extracted from a TypeDecl.
207struct TypeData {
208        TypeDecl::Kind kind;
209        bool isComplete;
210
211        TypeData() : kind( TypeDecl::NUMBER_OF_KINDS ), isComplete( false ) {}
212        TypeData( const TypeDecl * d ) : kind( d->kind ), isComplete( d->sized ) {}
213        TypeData( TypeDecl::Kind k, bool c ) : kind( k ), isComplete( c ) {}
214        TypeData( const TypeData & d1, const TypeData & d2 )
215                : kind( d1.kind ), isComplete( d1.isComplete || d2.isComplete ) {}
216
217        bool operator==( const TypeData & o ) const { return kind == o.kind && isComplete == o.isComplete; }
218        bool operator!=( const TypeData & o ) const { return !(*this == o); }
219};
220
221std::ostream & operator<< ( std::ostream &, const TypeData & );
222
223/// C-style typedef `typedef Foo Bar`
224class TypedefDecl final : public NamedTypeDecl {
225public:
226        TypedefDecl( const CodeLocation& loc, const std::string& name, Storage::Classes storage,
227                Type* b, Linkage::Spec spec = Linkage::Cforall )
228        : NamedTypeDecl( loc, name, storage, b, spec ) {}
229
230        const char * typeString() const override { return "typedef"; }
231
232        const Decl * accept( Visitor & v ) const override { return v.visit( this ); }
233private:
234        TypedefDecl * clone() const override { return new TypedefDecl{ *this }; }
235        MUTATE_FRIEND
236};
237
238/// Aggregate type declaration base class
239class AggregateDecl : public Decl {
240public:
241        enum Aggregate { Struct, Union, Enum, Exception, Trait, Generator, Coroutine, Monitor, Thread, NoAggregate };
242        static const char * aggrString( Aggregate aggr );
243
244        std::vector<ptr<Decl>> members;
245        std::vector<ptr<TypeDecl>> params;
246        std::vector<ptr<Attribute>> attributes;
247        bool body = false;
248        readonly<AggregateDecl> parent = {};
249
250        AggregateDecl( const CodeLocation& loc, const std::string& name,
251                std::vector<ptr<Attribute>>&& attrs = {}, Linkage::Spec linkage = Linkage::Cforall )
252        : Decl( loc, name, Storage::Classes{}, linkage ), members(), params(),
253          attributes( std::move(attrs) ) {}
254
255        AggregateDecl* set_body( bool b ) { body = b; return this; }
256
257        /// Produces a name for the kind of aggregate
258        virtual const char * typeString() const = 0;
259
260private:
261        AggregateDecl * clone() const override = 0;
262        MUTATE_FRIEND
263};
264
265/// struct declaration `struct Foo { ... };`
266class StructDecl final : public AggregateDecl {
267public:
268        Aggregate kind;
269
270        StructDecl( const CodeLocation& loc, const std::string& name,
271                Aggregate kind = Struct,
272                std::vector<ptr<Attribute>>&& attrs = {}, Linkage::Spec linkage = Linkage::Cforall )
273        : AggregateDecl( loc, name, std::move(attrs), linkage ), kind( kind ) {}
274
275        bool is_coroutine() const { return kind == Coroutine; }
276        bool is_generator() const { return kind == Generator; }
277        bool is_monitor  () const { return kind == Monitor  ; }
278        bool is_thread   () const { return kind == Thread   ; }
279
280        const Decl * accept( Visitor & v ) const override { return v.visit( this ); }
281
282        const char * typeString() const override { return aggrString( kind ); }
283
284private:
285        StructDecl * clone() const override { return new StructDecl{ *this }; }
286        MUTATE_FRIEND
287};
288
289/// union declaration `union Foo { ... };`
290class UnionDecl final : public AggregateDecl {
291public:
292        UnionDecl( const CodeLocation& loc, const std::string& name,
293                std::vector<ptr<Attribute>>&& attrs = {}, Linkage::Spec linkage = Linkage::Cforall )
294        : AggregateDecl( loc, name, std::move(attrs), linkage ) {}
295
296        const Decl * accept( Visitor& v ) const override { return v.visit( this ); }
297
298        const char * typeString() const override { return aggrString( Union ); }
299
300private:
301        UnionDecl * clone() const override { return new UnionDecl{ *this }; }
302        MUTATE_FRIEND
303};
304
305/// enum declaration `enum Foo { ... };`
306class EnumDecl final : public AggregateDecl {
307public:
308        // isTyped indicated if the enum has a declaration like:
309        // enum (type_optional) Name {...}
310        bool isTyped;
311        // if isTyped == true && base.get() == nullptr, it is a "void" type enum
312        ptr<Type> base;
313        enum class EnumHiding { Visible, Hide } hide;
314        EnumDecl( const CodeLocation& loc, const std::string& name, bool isTyped = false,
315                std::vector<ptr<Attribute>>&& attrs = {}, Linkage::Spec linkage = Linkage::Cforall,
316                Type const * base = nullptr, EnumHiding hide = EnumHiding::Hide,
317                std::unordered_map< std::string, long long > enumValues = std::unordered_map< std::string, long long >() )
318        : AggregateDecl( loc, name, std::move(attrs), linkage ), isTyped(isTyped), base(base), hide(hide), enumValues(enumValues) {}
319
320        /// gets the integer value for this enumerator, returning true iff value found
321        // Maybe it is not used in producing the enum value
322        bool valueOf( const Decl * enumerator, long long& value ) const;
323
324        const Decl * accept( Visitor & v ) const override { return v.visit( this ); }
325
326        const char * typeString() const override { return aggrString( Enum ); }
327
328
329private:
330        EnumDecl * clone() const override { return new EnumDecl{ *this }; }
331        MUTATE_FRIEND
332
333        /// Map from names to enumerator values; kept private for lazy initialization
334        mutable std::unordered_map< std::string, long long > enumValues;
335};
336
337/// trait declaration `trait Foo( ... ) { ... };`
338class TraitDecl final : public AggregateDecl {
339public:
340        TraitDecl( const CodeLocation& loc, const std::string& name,
341                std::vector<ptr<Attribute>>&& attrs = {}, Linkage::Spec linkage = Linkage::Cforall )
342        : AggregateDecl( loc, name, std::move(attrs), linkage ) {}
343
344        const Decl * accept( Visitor & v ) const override { return v.visit( this ); }
345
346        const char * typeString() const override { return "trait"; }
347
348private:
349        TraitDecl * clone() const override { return new TraitDecl{ *this }; }
350        MUTATE_FRIEND
351};
352
353/// With statement `with (...) ...`
354/// This is a statement lexically, but a Decl is needed for the SymbolTable.
355class WithStmt final : public Decl {
356public:
357        std::vector<ptr<Expr>> exprs;
358        ptr<Stmt> stmt;
359
360        WithStmt( const CodeLocation & loc, std::vector<ptr<Expr>> && exprs, const Stmt * stmt )
361        : Decl(loc, "", Storage::Auto, Linkage::Cforall), exprs(std::move(exprs)), stmt(stmt) {}
362
363        const Decl * accept( Visitor & v ) const override { return v.visit( this ); }
364private:
365        WithStmt * clone() const override { return new WithStmt{ *this }; }
366        MUTATE_FRIEND
367};
368
369/// Assembly declaration: `asm ... ( "..." : ... )`
370class AsmDecl final : public Decl {
371public:
372        ptr<AsmStmt> stmt;
373
374        AsmDecl( const CodeLocation & loc, AsmStmt * stmt )
375        : Decl( loc, "", {}, Linkage::C ), stmt(stmt) {}
376
377        const AsmDecl * accept( Visitor & v ) const override { return v.visit( this ); }
378private:
379        AsmDecl * clone() const override { return new AsmDecl( *this ); }
380        MUTATE_FRIEND
381};
382
383/// C-preprocessor directive `#...`
384class DirectiveDecl final : public Decl {
385public:
386        ptr<DirectiveStmt> stmt;
387
388        DirectiveDecl( const CodeLocation & loc, DirectiveStmt * stmt )
389        : Decl( loc, "", {}, Linkage::C ), stmt(stmt) {}
390
391        const DirectiveDecl * accept( Visitor & v ) const override { return v.visit( this ); }
392private:
393        DirectiveDecl * clone() const override { return new DirectiveDecl( *this ); }
394        MUTATE_FRIEND
395};
396
397/// Static Assertion `_Static_assert( ... , ... );`
398class StaticAssertDecl final : public Decl {
399public:
400        ptr<Expr> cond;
401        ptr<ConstantExpr> msg;   // string literal
402
403        StaticAssertDecl( const CodeLocation & loc, const Expr * condition, const ConstantExpr * msg )
404        : Decl( loc, "", {}, Linkage::C ), cond( condition ), msg( msg ) {}
405
406        const StaticAssertDecl * accept( Visitor & v ) const override { return v.visit( this ); }
407private:
408        StaticAssertDecl * clone() const override { return new StaticAssertDecl( *this ); }
409        MUTATE_FRIEND
410};
411
412/// Inline Member Declaration `inline TypeName;`
413class InlineMemberDecl final : public DeclWithType {
414public:
415        ptr<Type> type;
416
417        InlineMemberDecl( const CodeLocation & loc, const std::string & name, const Type * type,
418                Storage::Classes storage = {}, Linkage::Spec linkage = Linkage::Cforall,
419                std::vector< ptr<Attribute> > && attrs = {}, Function::Specs fs = {} )
420        : DeclWithType( loc, name, storage, linkage, std::move(attrs), fs ), type( type ) {}
421
422        const Type * get_type() const override { return type; }
423        void set_type( const Type * ty ) override { type = ty; }
424
425        const DeclWithType * accept( Visitor& v ) const override { return v.visit( this ); }
426private:
427        InlineMemberDecl * clone() const override { return new InlineMemberDecl{ *this }; }
428        MUTATE_FRIEND
429};
430
431}
432
433#undef MUTATE_FRIEND
434
435// Local Variables: //
436// tab-width: 4 //
437// mode: c++ //
438// compile-command: "make install" //
439// End: //
Note: See TracBrowser for help on using the repository browser.