Changeset a935892 for src/AST

Timestamp:

Jun 3, 2019, 10:54:01 AM (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:

0e315a5, dafe9e1

Parents:

043a5b6 (diff), 8d70648 (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

Location:

src/AST

Files:

• Convert.cpp (modified) (5 diffs)
• Decl.cpp (modified) (2 diffs)
• Decl.hpp (modified) (4 diffs)
• Expr.cpp (modified) (4 diffs)
• Node.hpp (modified) (2 diffs)
• Pass.hpp (modified) (1 diff)
• Pass.proto.hpp (modified) (1 diff)
• Print.hpp (modified) (2 diffs)
• SymbolTable.cpp (added)
• SymbolTable.hpp (added)
• Type.cpp (modified) (2 diffs)
• Type.hpp (modified) (4 diffs)
• TypeEnvironment.cpp (added)
• TypeEnvironment.hpp (added)
• module.mk (modified) (1 diff)
• porting.md (modified) (2 diffs)

src/AST/Convert.cpp

@@ -10 +10 @@
 // Created On       : Thu May 09 15::37::05 2019
 // Last Modified By : Andrew Beach
-// Last Modified On : Wed May 29 11:05:00 2019
-// Update Count     : 8
+// Last Modified On : Wed May 29 17:05:00 2019
+// Update Count     : 9
 //
 
@@ -77 +77 @@
                 std::list< T * > acceptL( const U & container ) {
                         std::list< T * > ret;
-                        for (auto ptr : container ) {
+                        for ( auto ptr : container ) {
                                 ret.emplace_back( accept1( ptr ) );
                         }
@@ -168 +168 @@
                         LinkageSpec::Spec( node->linkage.val ),
                         get<FunctionType>().accept1( node->type ),
-                        get<CompoundStmt>().accept1( node->stmts ),
+                        {},
                         get<Attribute>().acceptL( node->attributes ),
                         Type::FuncSpecifiers( node->funcSpec.val )
                 );
+                cache.emplace( node, decl );
+                decl->statements = get<CompoundStmt>().accept1( node->stmts );
                 decl->withExprs = get<Expression>().acceptL( node->withExprs );
                 if ( dereferenceOperator == node ) {
@@ -1446 +1448 @@
                         old->name,
                         GET_ACCEPT_1(type, FunctionType),
-                        GET_ACCEPT_1(statements, CompoundStmt),
+                        {},
                         { old->storageClasses.val },
                         { old->linkage.val },
@@ -1453 +1455 @@
                 };
                 cache.emplace( old, decl );
+                decl->withExprs = GET_ACCEPT_V(withExprs, Expr);
+                decl->stmts = GET_ACCEPT_1(statements, CompoundStmt);
                 decl->scopeLevel = old->scopeLevel;
                 decl->mangleName = old->mangleName;

src/AST/Decl.cpp

@@ -17 +17 @@
 
 #include <cassert>             // for assert, strict_dynamic_cast
+#include <iostream>
 #include <string>
 #include <unordered_map>
@@ -70 +71 @@
 }
 
+std::ostream & operator<< ( std::ostream & out, const TypeDecl::Data & data ) {
+        return out << data.kind << ", " << data.isComplete;
+}
+
 // --- EnumDecl
 

src/AST/Decl.hpp

@@ -16 +16 @@
 #pragma once
 
+#include <iosfwd>
 #include <string>              // for string, to_string
 #include <unordered_map>
@@ -121 +122 @@
         ptr<FunctionType> type;
         ptr<CompoundStmt> stmts;
-        std::list< ptr<Expr> > withExprs;
+        std::vector< ptr<Expr> > withExprs;
 
         FunctionDecl( const CodeLocation & loc, const std::string &name, FunctionType * type,
@@ -172 +173 @@
 
                 Data() : kind( (TypeVar::Kind)-1 ), isComplete( false ) {}
-                Data( TypeDecl* d ) : kind( d->kind ), isComplete( d->sized ) {}
+                Data( const TypeDecl * d ) : kind( d->kind ), isComplete( d->sized ) {}
                 Data( TypeVar::Kind k, bool c ) : kind( k ), isComplete( c ) {}
-                Data( const Data& d1, const Data& d2 )
+                Data( const Data & d1, const Data & d2 )
                 : kind( d1.kind ), isComplete( d1.isComplete || d2.isComplete ) {}
 
-                bool operator== ( const Data& o ) const {
+                bool operator== ( const Data & o ) const {
                         return kind == o.kind && isComplete == o.isComplete;
                 }
-                bool operator!= ( const Data& o ) const { return !(*this == o); }
+                bool operator!= ( const Data & o ) const { return !(*this == o); }
         };
 
@@ -200 +201 @@
         MUTATE_FRIEND
 };
+
+std::ostream & operator<< ( std::ostream &, const TypeDecl::Data & );
 
 /// C-style typedef `typedef Foo Bar`

src/AST/Expr.cpp

@@ -64 +64 @@
                         // references have been removed, in which case dereference returns an lvalue of the
                         // base type
-                        ret->result.set_and_mutate( base )->set_lvalue( true );
+                        ret->result = base;
+                        add_lvalue( ret->result );
                 }
         }
@@ -173 +174 @@
         assert( var );
         assert( var->get_type() );
-        result.set_and_mutate( var->get_type() )->set_lvalue( true );
+        result = var->get_type();
+        add_lvalue( result );
 }
 
@@ -306 +308 @@
 : Expr( loc ), init( i ) {
         assert( t && i );
-        result.set_and_mutate( t )->set_lvalue( true );
+        result = t;
+        add_lvalue( result );
 }
 
@@ -322 +325 @@
                 "index %d in expr %s", type->size(), index, toString( tuple ).c_str() );
         // like MemberExpr, TupleIndexExpr is always an lvalue
-        result.set_and_mutate( type->types[ index ] )->set_lvalue( true );
+        result = type->types[ index ];
+        add_lvalue( result );
 }
 

src/AST/Node.hpp

@@ -113 +113 @@
         }
 
-        ptr_base( ptr_base && o ) : node(o.node) {
-                if( node ) _inc(node);
-        }
+        ptr_base( ptr_base && o ) : node(o.node) { o.node = nullptr; }
 
         template< enum Node::ref_type o_ref_t >
@@ -139 +137 @@
 
         ptr_base & operator=( ptr_base && o ) {
-                assign(o.node);
+                if ( node == o.node ) return *this;
+                if ( node ) _dec(node);
+                node = o.node;
+                o.node = nullptr;
                 return *this;
         }

src/AST/Pass.hpp

@@ -179 +179 @@
 
         template<typename pass_type>
-        friend void acceptAll( std::list< ptr<Decl> > & decls, Pass<pass_type>& visitor );
+        friend void accept_all( std::list< ptr<Decl> > & decls, Pass<pass_type>& visitor );
 private:
 

src/AST/Pass.proto.hpp

@@ -312 +312 @@
                 INDEXER_FUNC1( addTrait  , const TraitDecl *     );
                 INDEXER_FUNC2( addWith   , const std::vector< ptr<Expr> > &, const Node * );
-                INDEXER_FUNC2( addWith   , const std::list  < ptr<Expr> > &, const Node * );
 
                 // A few extra functions have more complicated behaviour, they are hand written

src/AST/Print.hpp

@@ -17 +17 @@
 
 #include <iosfwd>
+#include <utility> // for forward
 
 #include "AST/Node.hpp"
@@ -28 +29 @@
 void print( std::ostream & os, const ast::Node * node, Indenter indent = {} );
 
-inline void print( std::ostream & os, const ast::Node * node, unsigned int indent ) {
-    print( os, node, Indenter{ Indenter::tabsize, indent });
+/// Wrap any standard format printer (matching above) with integer Indenter constructor
+template<typename T>
+inline void print( std::ostream & os, T && x, unsigned int indent ) {
+    print( os, std::forward<T>(x), Indenter{ Indenter::tabsize, indent });
 }
 

src/AST/Type.cpp

@@ -27 +27 @@
 namespace ast {
 
-const Type * Type::getComponent( unsigned i ) {
+const Type * Type::getComponent( unsigned i ) const {
         assertf( size() == 1 && i == 0, "Type::getComponent was called with size %d and index %d\n", size(), i );
         return this;
 }
 
-const Type * Type::stripDeclarator() {
+const Type * Type::stripDeclarator() const {
         const Type * t;
         const Type * a;
@@ -39 +39 @@
 }
 
-const Type * Type::stripReferences() {
+const Type * Type::stripReferences() const {
         const Type * t;
         const ReferenceType * r;

src/AST/Type.hpp

@@ -25 +25 @@
 #include "Decl.hpp"          // for AggregateDecl subclasses
 #include "Fwd.hpp"
-#include "Node.hpp"          // for Node, ptr
+#include "Node.hpp"          // for Node, ptr, ptr_base
 #include "TypeVar.hpp"
 #include "Visitor.hpp"
@@ -58 +58 @@
         virtual bool isVoid() const { return size() == 0; }
         /// Get the i'th component of this type
-        virtual const Type * getComponent( unsigned i );
+        virtual const Type * getComponent( unsigned i ) const;
 
         /// type without outer pointers and arrays
-        const Type * stripDeclarator();
+        const Type * stripDeclarator() const;
         /// type without outer references
-        const Type * stripReferences();
+        const Type * stripReferences() const;
         /// number of reference occuring consecutively on the outermost layer of this type
         /// (i.e. do not count references nested within other types)
@@ -75 +75 @@
         MUTATE_FRIEND
 };
+
+/// Set the `is_lvalue` qualifier on this type, cloning only if necessary
+template< enum Node::ref_type ref_t >
+void add_lvalue( ptr_base< Type, ref_t > & p ) {
+        if ( ! p->qualifiers.is_lvalue ) p.get_and_mutate()->qualifiers.is_lvalue = true;
+}
+
+/// Clear the qualifiers on this type, cloning only if necessary
+template< enum Node::ref_type ref_t >
+void clear_qualifiers( ptr_base< Type, ref_t > & p ) {
+        if ( p->qualifiers != CV::Qualifiers{} ) p.get_and_mutate()->qualifiers = CV::Qualifiers{};
+}
 
 /// `void`
@@ -437 +449 @@
         unsigned size() const override { return types.size(); }
 
-        const Type * getComponent( unsigned i ) override {
+        const Type * getComponent( unsigned i ) const override {
                 assertf( i < size(), "TupleType::getComponent: index %d must be less than size %d",
                         i, size() );

src/AST/module.mk

@@ -28 +28 @@
         AST/Print.cpp \
         AST/Stmt.cpp \
+        AST/SymbolTable.cpp \
         AST/Type.cpp \
+        AST/TypeEnvironment.cpp \
         AST/TypeSubstitution.cpp
 

src/AST/porting.md

@@ -104 +104 @@
           * `LinkageSpec::isMangled(Spec)` etc. => `Spec.is_mangled` etc.
           * `LinkageSpec::Intrinsic` etc. => `ast::Linkage::Intrinsic` etc.
+  * Boolean flags to `SymTab::Mangler::mangle` are now a `SymTab::Mangle::Mode` struct
+    * uses `bitfield`
+  * Because `Indexer` isn't a terribly evocative name:
+    * `SymTab::Indexer` => `ast::SymbolTable`
+    * `SymTab/Indexer.{h,cc}` => `AST/SymbolTable.{hpp,cpp}`
+    * **TODO** `WithIndexer` => `WithSymbolTable`
+      * `indexer` => `symTab`
+    * `IdData::deleteStmt` => `IdData::deleter`
+    * `lookupId()` now returns a vector rather than an out-param list
+    * To avoid name collisions:
+      * `SymTab::Mangler` => `Mangle`
+  * `ResolvExpr::TypeEnvironment` => `ast::TypeEnvironment`
+    * in `AST/TypeEnvironment.hpp`
 * Boolean constructor parameters get replaced with a dedicated flag enum:
   * e.g. `bool isVarLen;` => `enum LengthFlag { FixedLen, VariableLen };` `LengthFlag isVarLen;`
@@ -261 +274 @@
   * feature is `type@thing` e.g. `int@MAX`
 
+`referenceToRvalueConversion`
+* now returns `const Expr *` rather than mutating argument
+
+`printAssertionSet`, `printOpenVarSet`
+* `ostream &` now first argument, for consistency
+
+`EqvClass`
+* `type` => `bound`
+
+`TypeEnvironment`
+* `makeSubstitution()` => `writeToSubstitution()`
+* `isEmpty()` => `empty()`
+* removed `clone()` in favour of explicit copies
+
+`occurs`
+* moved to be helper function in `TypeEnvironment.cpp` (its only use)
+
 [1] https://gcc.gnu.org/onlinedocs/gcc-9.1.0/gcc/Type-Attributes.html#Type-Attributes