Changes in src/Tuples/Tuples.cc [c6b4432:e01eb4a]

File:

• src/Tuples/Tuples.cc (modified) (3 diffs)

src/Tuples/Tuples.cc

@@ -19 +19 @@
 #include "AST/Inspect.hpp"
 #include "AST/LinkageSpec.hpp"
+#include "Common/PassVisitor.h"
 #include "InitTweak/InitTweak.h"
 
@@ -24 +25 @@
 
 namespace {
+        /// Checks if impurity (read: side-effects) may exist in a piece of code.
+        /// Currently gives a very crude approximation, wherein any function
+        /// call expression means the code may be impure.
+        struct ImpurityDetector_old : public WithShortCircuiting {
+                bool const ignoreUnique;
+                bool maybeImpure;
+
+                ImpurityDetector_old( bool ignoreUnique ) :
+                        ignoreUnique( ignoreUnique ), maybeImpure( false )
+                {}
+
+                void previsit( const ApplicationExpr * appExpr ) {
+                        visit_children = false;
+                        if ( const DeclarationWithType * function =
+                                        InitTweak::getFunction( appExpr ) ) {
+                                if ( function->linkage == LinkageSpec::Intrinsic ) {
+                                        if ( function->name == "*?" || function->name == "?[?]" ) {
+                                                // intrinsic dereference, subscript are pure,
+                                                // but need to recursively look for impurity
+                                                visit_children = true;
+                                                return;
+                                        }
+                                }
+                        }
+                        maybeImpure = true;
+                }
+
+                void previsit( const UntypedExpr * ) {
+                        maybeImpure = true;
+                        visit_children = false;
+                }
+
+                void previsit( const UniqueExpr * ) {
+                        if ( ignoreUnique ) {
+                                // bottom out at unique expression.
+                                // The existence of a unique expression doesn't change the purity of an expression.
+                                // That is, even if the wrapped expression is impure, the wrapper protects the rest of the expression.
+                                visit_children = false;
+                                return;
+                        }
+                }
+        };
+
+        bool detectImpurity( const Expression * expr, bool ignoreUnique ) {
+                PassVisitor<ImpurityDetector_old> detector( ignoreUnique );
+                expr->accept( detector );
+                return detector.pass.maybeImpure;
+        }
 
         /// Determines if impurity (read: side-effects) may exist in a piece of code. Currently gives
@@ -61 +110 @@
 }
 
+bool maybeImpure( const Expression * expr ) {
+        return detectImpurity( expr, false );
+}
+
+bool maybeImpureIgnoreUnique( const Expression * expr ) {
+        return detectImpurity( expr, true );
+}
+
 } // namespace Tuples