Changeset 67130fe for src/AST

Timestamp:

Jun 4, 2019, 6:39:23 PM (6 years ago)

Author:

Peter A. Buhr <pabuhr@…>

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:

c6a1e8a

Parents:

7564e10 (diff), 1346914 (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) (7 diffs)
• Decl.cpp (modified) (2 diffs)
• Decl.hpp (modified) (5 diffs)
• Expr.cpp (modified) (5 diffs)
• Node.hpp (modified) (8 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) (5 diffs)
• TypeEnvironment.cpp (added)
• TypeEnvironment.hpp (added)
• TypeSubstitution.cpp (modified) (2 diffs)
• module.mk (modified) (1 diff)
• porting.md (modified) (2 diffs)

src/AST/Convert.cpp

@@ -47 +47 @@
 namespace {
 
-// This is to preserve the SymTab::dereferenceOperator hack. It does not (and perhaps should not)
+// This is to preserve the FindSpecialDecls hack. It does not (and perhaps should not)
 // allow us to use the same stratagy in the new ast.
 ast::FunctionDecl * dereferenceOperator = nullptr;
+ast::StructDecl   * dtorStruct = nullptr;
+ast::FunctionDecl * dtorStructDestroy = nullptr;
 
 }
@@ -75 +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 ) );
                         }
@@ -176 +178 @@
                         Validate::dereferenceOperator = decl;
                 }
+                if ( dtorStructDestroy == node ) {
+                        Validate::dtorStructDestroy = decl;
+                }
                 return declWithTypePostamble( decl, node );
         }
@@ -231 +236 @@
                         LinkageSpec::Spec( node->linkage.val )
                 );
+
+                if ( dtorStruct == node ) {
+                        Validate::dtorStruct = decl;
+                }
+
                 return aggregatePostamble( decl, node );
         }
@@ -1445 +1455 @@
                 };
                 cache.emplace( old, decl );
+                decl->withExprs = GET_ACCEPT_V(withExprs, Expr);
                 decl->stmts = GET_ACCEPT_1(statements, CompoundStmt);
                 decl->scopeLevel = old->scopeLevel;
@@ -1456 +1467 @@
                 if ( Validate::dereferenceOperator == old ) {
                         dereferenceOperator = decl;
+                }
+
+                if ( Validate::dtorStructDestroy == old ) {
+                        dtorStructDestroy = decl;
                 }
         }
@@ -1478 +1493 @@
 
                 this->node = decl;
+
+                if ( Validate::dtorStruct == old ) {
+                        dtorStruct = decl;
+                }
         }
 

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>
@@ -101 +102 @@
         ptr<Expr> bitfieldWidth;
 
-        ObjectDecl( const CodeLocation & loc, const std::string & name, const Type * type, Init * init = nullptr,
-                Storage::Classes storage = {}, Linkage::Spec linkage = Linkage::C, Expr * bitWd = nullptr,
-                std::vector< ptr<Attribute> > && attrs = {}, Function::Specs fs = {})
+        ObjectDecl( const CodeLocation & loc, const std::string & name, const Type * type, 
+                Init * init = nullptr, Storage::Classes storage = {}, Linkage::Spec linkage = Linkage::C, 
+                Expr * bitWd = nullptr, std::vector< ptr<Attribute> > && attrs = {}, 
+                Function::Specs fs = {} )
         : DeclWithType( loc, name, storage, linkage, std::move(attrs), fs ), type( type ),
           init( init ), bitfieldWidth( bitWd ) {}
@@ -121 +123 @@
         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 +174 @@
 
                 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 +202 @@
         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_qualifiers( ret->result, CV::Lvalue );
                 }
         }
@@ -164 +165 @@
         genericSubsitution( aggregate->result ).apply( result );
         // ensure lvalue and appropriate restrictions from aggregate type
-        result.get_and_mutate()->qualifiers |= aggregate->result->qualifiers | CV::Lvalue;
+        add_qualifiers( result, aggregate->result->qualifiers | CV::Lvalue );
 }
 
@@ -173 +174 @@
         assert( var );
         assert( var->get_type() );
-        result.set_and_mutate( var->get_type() )->set_lvalue( true );
+        result = var->get_type();
+        add_qualifiers( result, CV::Lvalue );
 }
 
@@ -306 +308 @@
 : Expr( loc ), init( i ) {
         assert( t && i );
-        result.set_and_mutate( t )->set_lvalue( true );
+        result = t;
+        add_qualifiers( result, CV::Lvalue );
 }
 
@@ -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_qualifiers( result, CV::Lvalue );
 }
 

src/AST/Node.hpp

@@ -10 +10 @@
 // Created On       : Wed May 8 10:27:04 2019
 // Last Modified By : Andrew Beach
-// Last Modified On : Thu May 23 16:00:00 2019
-// Update Count     : 4
+// Last Modified On : Mon Jun  3 13:26:00 2019
+// Update Count     : 5
 //
 
@@ -18 +18 @@
 #include <cassert>
 #include <iosfwd>
+
+#include "Common/ErrorObjects.h"  // for SemanticErrorException
 
 namespace ast {
@@ -100 +102 @@
 }
 
+/// Call a visitor on a collection of nodes, throwing any exceptions when completed
+template< typename Container >
+void accept_each( const Container & c, Visitor & v ) {
+        SemanticErrorException errors;
+        for ( const auto & i : c ) {
+                try {
+                        if ( i ) {
+                                i->accept( v );
+                        }
+                } catch ( SemanticErrorException & e ) {
+                        errors.append( e );
+                }
+        }
+        if ( ! errors.isEmpty() ) {
+                throw errors;
+        }
+}
+
 /// Base class for the smart pointer types
 /// should never really be used.
@@ -107 +127 @@
         ptr_base() : node(nullptr) {}
         ptr_base( const node_t * n ) : node(n) { if( node ) _inc(node); }
-        ~ptr_base() { if( node ) _dec(node); }
+        ~ptr_base() { if( node ) { auto tmp = node; node = nullptr; _dec(tmp); } }
 
         ptr_base( const ptr_base & o ) : node(o.node) {
@@ -113 +133 @@
         }
 
-        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 >
@@ -129 +147 @@
         template<typename o_node_t>
         ptr_base & operator=( const o_node_t * node ) {
-                assign( node ? strict_dynamic_cast<const node_t *>(node) : nullptr );
+                assign( strict_dynamic_cast<const node_t *, nullptr>(node) );
                 return *this;
         }
@@ -139 +157 @@
 
         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;
         }
@@ -165 +186 @@
         const o_node_t * as() const { return dynamic_cast<const o_node_t *>(node); }
 
+        /// wrapper for convenient access to strict_dynamic_cast
+        template<typename o_node_t>
+        const o_node_t * strict_as() const { return strict_dynamic_cast<const o_node_t *>(node); }
+
         /// Returns a mutable version of the pointer in this node.
         node_t * get_and_mutate();

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"
@@ -48 +48 @@
 
         Type * set_const( bool v ) { qualifiers.is_const = v; return this; }
+        Type * set_volatile( bool v ) { qualifiers.is_volatile = v; return this; }
         Type * set_restrict( bool v ) { qualifiers.is_restrict = v; return this; }
         Type * set_lvalue( bool v ) { qualifiers.is_lvalue = v; return this; }
@@ -58 +59 @@
         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 +76 @@
         MUTATE_FRIEND
 };
+
+/// Clear/reset the qualifiers on this type, cloning only if necessary
+template< enum Node::ref_type ref_t >
+void reset_qualifiers( ptr_base< Type, ref_t > & p, CV::Qualifiers q = {} ) {
+        if ( p->qualifiers.val != q.val ) p.get_and_mutate()->qualifiers = q;
+}
+
+/// Add the specified qualifiers to this type, cloning only if necessary
+template< enum Node::ref_type ref_t >
+void add_qualifiers( ptr_base< Type, ref_t > & p, CV::Qualifiers q ) {
+        if ( ( p->qualifiers.val & q.val ) != q.val ) p.get_and_mutate()->qualifiers |= q;
+}
+
+/// Remove the specified qualifiers from this type, cloning only if necessary
+template< enum Node::ref_type ref_t >
+void remove_qualifiers( ptr_base< Type, ref_t > & p, CV::Qualifiers q ) {
+        if ( ( p->qualifiers.val & q.val ) != 0 ) p.get_and_mutate()->qualifiers -= q;
+}
 
 /// `void`
@@ -437 +456 @@
         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/TypeSubstitution.cpp

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Mar 16 15:54:35 2017
-// Update Count     : 4
+// Last Modified By : Andrew Beach
+// Last Modified On : Mon Jun  3 13:26:00 2017
+// Update Count     : 5
 //
 
@@ -26 +26 @@
 }
 
-TypeSubstitution::~TypeSubstitution() {
-        for ( TypeEnvType::iterator i = typeEnv.begin(); i != typeEnv.end(); ++i ) {
-                delete( i->second );
-        }
-        for ( VarEnvType::iterator i = varEnv.begin(); i != varEnv.end(); ++i ) {
-                delete( i->second );
-        }
-}
+TypeSubstitution::~TypeSubstitution() {}
 
 TypeSubstitution &TypeSubstitution::operator=( const TypeSubstitution &other ) {

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)
+
+`WidenMode`
+* changed `widenFirst`, `widenSecond` => `first`, `second`
+* changed `WidenMode widenMode` => `WidenMode widen`
+
 [1] https://gcc.gnu.org/onlinedocs/gcc-9.1.0/gcc/Type-Attributes.html#Type-Attributes