Changeset da7fe39 for src/SynTree

Timestamp:

Apr 23, 2018, 12:57:46 PM (8 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, stuck-waitfor-destruct, with_gc

Children:

57acae0

Parents:

ba89e9b7 (diff), c8ad5d9 (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' into references

Location:

src/SynTree

Files:

• CompoundStmt.cc (modified) (3 diffs)
• DeclReplacer.cc (added)
• DeclReplacer.h (moved) (moved from src/SynTree/VarExprReplacer.h ) (1 diff)
• Expression.cc (modified) (2 diffs)
• Expression.h (modified) (2 diffs)
• FunctionDecl.cc (modified) (3 diffs)
• Mutator.h (modified) (1 diff)
• SynTree.h (modified) (1 diff)
• TypeSubstitution.cc (modified) (1 diff)
• TypeSubstitution.h (modified) (1 diff)
• VarExprReplacer.cc (deleted)
• Visitor.h (modified) (1 diff)
• module.mk (modified) (1 diff)

src/SynTree/CompoundStmt.cc

@@ -23 +23 @@
 #include "Statement.h"                // for CompoundStmt, Statement, DeclStmt
 #include "SynTree/Label.h"            // for Label
-#include "SynTree/VarExprReplacer.h"  // for VarExprReplacer, VarExprReplace...
+#include "SynTree/DeclReplacer.h"     // for DeclReplacer
 
 using std::string;
@@ -49 +49 @@
         // recursively execute this routine. There may be more efficient ways of doing
         // this.
-        VarExprReplacer::DeclMap declMap;
+        DeclReplacer::DeclMap declMap;
         std::list< Statement * >::const_iterator origit = other.kids.begin();
         for ( Statement * s : kids ) {
@@ -64 +64 @@
         }
         if ( ! declMap.empty() ) {
-                VarExprReplacer::replace( this, declMap );
+                DeclReplacer::replace( this, declMap );
         }
 }

src/SynTree/DeclReplacer.h

@@ -23 +23 @@
 class VariableExpr;
 
-namespace VarExprReplacer {
+namespace DeclReplacer {
         typedef std::map< DeclarationWithType *, DeclarationWithType * > DeclMap;
+        typedef std::map< TypeDecl *, TypeDecl * > TypeMap;
 
         void replace( BaseSyntaxNode * node, const DeclMap & declMap, bool debug = false );
+        void replace( BaseSyntaxNode * node, const TypeMap & typeMap, bool debug = false );
+        void replace( BaseSyntaxNode * node, const DeclMap & declMap, const TypeMap & typeMap, bool debug = false );
 }
 

src/SynTree/Expression.cc

@@ -271 +271 @@
 }
 
-CastExpr::CastExpr( Expression *arg_, Type *toType ) : Expression(), arg(arg_) {
+CastExpr::CastExpr( Expression *arg, Type *toType, bool isGenerated ) : Expression(), arg(arg), isGenerated( isGenerated ) {
         set_result(toType);
 }
 
-CastExpr::CastExpr( Expression *arg_ ) : Expression(), arg(arg_) {
+CastExpr::CastExpr( Expression *arg, bool isGenerated ) : Expression(), arg(arg), isGenerated( isGenerated ) {
         set_result( new VoidType( Type::Qualifiers() ) );
 }
 
-CastExpr::CastExpr( const CastExpr &other ) : Expression( other ), arg( maybeClone( other.arg ) ) {
+CastExpr::CastExpr( const CastExpr &other ) : Expression( other ), arg( maybeClone( other.arg ) ), isGenerated( other.isGenerated ) {
 }
 
@@ -296 +296 @@
                 result->print( os, indent+1 );
         } // if
+        Expression::print( os, indent );
+}
+
+KeywordCastExpr::KeywordCastExpr( Expression *arg, Target target ) : Expression(), arg(arg), target( target ) {
+}
+
+KeywordCastExpr::KeywordCastExpr( const KeywordCastExpr &other ) : Expression( other ), arg( maybeClone( other.arg ) ), target( other.target ) {
+}
+
+KeywordCastExpr::~KeywordCastExpr() {
+        delete arg;
+}
+
+const std::string & KeywordCastExpr::targetString() const {
+        static const std::string targetStrs[] = {
+                "coroutine", "thread", "monitor"
+        };
+        static_assert(
+                (sizeof(targetStrs) / sizeof(targetStrs[0])) == ((unsigned long)NUMBER_OF_TARGETS),
+                "Each KeywordCastExpr::Target should have a corresponding string representation"
+        );
+        return targetStrs[(unsigned long)target];
+}
+
+void KeywordCastExpr::print( std::ostream &os, Indenter indent ) const {
+        os << "Keyword Cast of:" << std::endl << indent+1;
+        arg->print(os, indent+1);
+        os << std::endl << indent << "... to: ";
+        os << targetString();
         Expression::print( os, indent );
 }

src/SynTree/Expression.h

@@ -188 +188 @@
   public:
         Expression * arg;
-
-        CastExpr( Expression * arg );
-        CastExpr( Expression * arg, Type * toType );
+        bool isGenerated = true; // whether this cast appeared in the source program
+
+        CastExpr( Expression * arg, bool isGenerated = true );
+        CastExpr( Expression * arg, Type * toType, bool isGenerated = true );
+        CastExpr( Expression * arg, void * ) = delete; // prevent accidentally passing pointers for isGenerated in the first constructor
         CastExpr( const CastExpr & other );
         virtual ~CastExpr();
@@ -198 +200 @@
 
         virtual CastExpr * clone() const { return new CastExpr( * this ); }
+        virtual void accept( Visitor & v ) { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
+};
+
+/// KeywordCastExpr represents a cast to 'keyword types', e.g. (thread &)t
+class KeywordCastExpr : public Expression {
+public:
+        Expression * arg;
+        enum Target {
+                Coroutine, Thread, Monitor, NUMBER_OF_TARGETS
+        } target;
+
+        KeywordCastExpr( Expression * arg, Target target );
+        KeywordCastExpr( const KeywordCastExpr & other );
+        virtual ~KeywordCastExpr();
+
+        const std::string & targetString() const;
+
+        virtual KeywordCastExpr * clone() const { return new KeywordCastExpr( * this ); }
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }

src/SynTree/FunctionDecl.cc

@@ -26 +26 @@
 #include "Statement.h"           // for CompoundStmt
 #include "Type.h"                // for Type, FunctionType, Type::FuncSpecif...
-#include "VarExprReplacer.h"
+#include "DeclReplacer.h"
 
 extern bool translation_unit_nomain;
@@ -41 +41 @@
                 : Parent( other ), type( maybeClone( other.type ) ), statements( maybeClone( other.statements ) ) {
 
-        VarExprReplacer::DeclMap declMap;
+        DeclReplacer::DeclMap declMap;
         for ( auto p : group_iterate( other.type->parameters, type->parameters ) ) {
                 declMap[ std::get<0>(p) ] = std::get<1>(p);
@@ -49 +49 @@
         }
         if ( ! declMap.empty() ) {
-                VarExprReplacer::replace( this, declMap );
+                DeclReplacer::replace( this, declMap );
         }
         cloneAll( other.withExprs, withExprs );

src/SynTree/Mutator.h

@@ -59 +59 @@
         virtual Expression * mutate( UntypedExpr * untypedExpr ) = 0;
         virtual Expression * mutate( NameExpr * nameExpr ) = 0;
-        virtual Expression * mutate( AddressExpr * castExpr ) = 0;
+        virtual Expression * mutate( AddressExpr * addrExpr ) = 0;
         virtual Expression * mutate( LabelAddressExpr * labAddressExpr ) = 0;
         virtual Expression * mutate( CastExpr * castExpr ) = 0;
+        virtual Expression * mutate( KeywordCastExpr * castExpr ) = 0;
         virtual Expression * mutate( VirtualCastExpr * castExpr ) = 0;
         virtual Expression * mutate( UntypedMemberExpr * memberExpr ) = 0;

src/SynTree/SynTree.h

@@ -69 +69 @@
 class LabelAddressExpr;
 class CastExpr;
+class KeywordCastExpr;
 class VirtualCastExpr;
 class MemberExpr;

src/SynTree/TypeSubstitution.cc

@@ -149 +149 @@
                 return inst;
         } else {
-///         std::cerr << "found " << inst->get_name() << ", replacing with ";
-///         i->second->print( std::cerr );
-///         std::cerr << std::endl;
+                // cut off infinite loop for the case where a type is bound to itself.
+                // Note: this does not prevent cycles in the general case, so it may be necessary to do something more sophisticated here.
+                // TODO: investigate preventing type variables from being bound to themselves in the first place.
+                if ( TypeInstType * replacement = dynamic_cast< TypeInstType * >( i->second ) ) {
+                        if ( inst->name == replacement->name ) {
+                                return inst;
+                        }
+                }
+                // std::cerr << "found " << inst->name << ", replacing with " << i->second << std::endl;
                 subCount++;
                 Type * newtype = i->second->clone();
                 newtype->get_qualifiers() |= inst->get_qualifiers();
                 delete inst;
-                return newtype;
+                // Note: need to recursively apply substitution to the new type because normalize does not substitute bound vars, but bound vars must be substituted when not in freeOnly mode.
+                return newtype->acceptMutator( *visitor );
         } // if
 }

src/SynTree/TypeSubstitution.h

@@ -129 +129 @@
 
 // definitition must happen after PassVisitor is included so that WithGuards can be used
-struct TypeSubstitution::Substituter : public WithGuards {
+struct TypeSubstitution::Substituter : public WithGuards, public WithVisitorRef<Substituter> {
                 Substituter( TypeSubstitution & sub, bool freeOnly ) : sub( sub ), freeOnly( freeOnly ) {}
 

src/SynTree/Visitor.h

@@ -62 +62 @@
         virtual void visit( NameExpr * nameExpr ) = 0;
         virtual void visit( CastExpr * castExpr ) = 0;
+        virtual void visit( KeywordCastExpr * castExpr ) = 0;
         virtual void visit( VirtualCastExpr * castExpr ) = 0;
         virtual void visit( AddressExpr * addressExpr ) = 0;

src/SynTree/module.mk

@@ -48 +48 @@
        SynTree/TypeSubstitution.cc \
        SynTree/Attribute.cc \
-       SynTree/VarExprReplacer.cc
+       SynTree/DeclReplacer.cc