Changeset c6b4432 for src/Tuples/Tuples.cc

Timestamp:

Nov 8, 2023, 2:01:11 PM (7 months ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

master

Children:

3e4bf0d, f5ec35a

Parents:

790d835

Message:

Remove BaseSyntaxNode? and clean-up.

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"
 
@@ -25 +24 @@
 
 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
@@ -110 +61 @@
 }
 
-bool maybeImpure( const Expression * expr ) {
-        return detectImpurity( expr, false );
-}
-
-bool maybeImpureIgnoreUnique( const Expression * expr ) {
-        return detectImpurity( expr, true );
-}
-
 } // namespace Tuples