Changes in src/Tuples/TupleExpansion.cc [b4f8808:aee472e]

File:

• src/Tuples/TupleExpansion.cc (modified) (10 diffs)

src/Tuples/TupleExpansion.cc

@@ -9 +9 @@
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Andrew Beach
-// Last Modified On : Fri Jul 19 14:39:00 2019
-// Update Count     : 22
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Wed Jun 21 17:35:04 2017
+// Update Count     : 19
 //
 
@@ -17 +17 @@
 #include <cassert>                // for assert
 #include <list>                   // for list
-#include <vector>
-
-#include "AST/CVQualifiers.hpp"
-#include "AST/Expr.hpp"
-#include "AST/Node.hpp"
-#include "AST/Type.hpp"
+
 #include "Common/PassVisitor.h"   // for PassVisitor, WithDeclsToAdd, WithGu...
 #include "Common/ScopedMap.h"     // for ScopedMap
@@ -63 +58 @@
                 };
 
-                struct TupleTypeReplacer : public WithDeclsToAdd, public WithGuards, public WithConstTypeSubstitution {
+                struct TupleTypeReplacer : public WithDeclsToAdd, public WithGuards, public WithTypeSubstitution {
                         Type * postmutate( TupleType * tupleType );
 
@@ -304 +299 @@
                 // produce the TupleType which aggregates the types of the exprs
                 std::list< Type * > types;
-                Type::Qualifiers qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Atomic | Type::Mutex );
+                Type::Qualifiers qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Lvalue | Type::Atomic | Type::Mutex );
                 for ( Expression * expr : exprs ) {
                         assert( expr->get_result() );
@@ -319 +314 @@
                 return new TupleType( qualifiers, types );
         }
-        const ast::Type * makeTupleType( const std::vector<ast::ptr<ast::Expr>> & exprs ) {
-                // produce the TupleType which aggregates the types of the exprs
-                std::vector<ast::ptr<ast::Type>> types;
-                ast::CV::Qualifiers quals{
-                        ast::CV::Const | ast::CV::Volatile | ast::CV::Restrict | ast::CV::Lvalue |
-                        ast::CV::Atomic | ast::CV::Mutex };
-
-                for ( const ast::Expr * expr : exprs ) {
-                        assert( expr->result );
-                        // if the type of any expr is void, the type of the entire tuple is void
-                        if ( expr->result->isVoid() ) return new ast::VoidType{};
-
-                        // qualifiers on the tuple type are the qualifiers that exist on all components
-                        quals &= expr->result->qualifiers;
-
-                        types.emplace_back( expr->result );
-                }
-
-                if ( exprs.empty() ) { quals = ast::CV::Qualifiers{}; }
-                return new ast::TupleType{ std::move(types), quals };
-        }
 
         TypeInstType * isTtype( Type * type ) {
@@ -350 +324 @@
         }
 
-        const TypeInstType * isTtype( const Type * type ) {
-                if ( const TypeInstType * inst = dynamic_cast< const TypeInstType * >( type ) ) {
-                        if ( inst->baseType && inst->baseType->kind == TypeDecl::Ttype ) {
-                                return inst;
-                        }
-                }
-                return nullptr;
-        }
-
-        const ast::TypeInstType * isTtype( const ast::Type * type ) {
-                if ( const ast::TypeInstType * inst = dynamic_cast< const ast::TypeInstType * >( type ) ) {
-                        if ( inst->base && inst->base->kind == ast::TypeVar::Ttype ) {
-                                return inst;
-                        }
-                }
-                return nullptr;
-        }
-
         namespace {
                 /// determines 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
@@ -373 +329 @@
                         ImpurityDetector( bool ignoreUnique ) : ignoreUnique( ignoreUnique ) {}
 
-                        void previsit( const ApplicationExpr * appExpr ) {
+                        void previsit( ApplicationExpr * appExpr ) {
                                 visit_children = false;
-                                if ( const DeclarationWithType * function = InitTweak::getFunction( appExpr ) ) {
-                                        if ( function->linkage == LinkageSpec::Intrinsic ) {
-                                                if ( function->name == "*?" || function->name == "?[?]" ) {
+                                if ( DeclarationWithType * function = InitTweak::getFunction( appExpr ) ) {
+                                        if ( function->get_linkage() == LinkageSpec::Intrinsic ) {
+                                                if ( function->get_name() == "*?" || function->get_name() == "?[?]" ) {
                                                         // intrinsic dereference, subscript are pure, but need to recursively look for impurity
                                                         visit_children = true;
@@ -386 +342 @@
                                 maybeImpure = true;
                         }
-                        void previsit( const UntypedExpr * ) { maybeImpure = true; visit_children = false; }
-                        void previsit( const UniqueExpr * ) {
+                        void previsit( UntypedExpr * ) { maybeImpure = true; visit_children = false; }
+                        void previsit( UniqueExpr * ) {
                                 if ( ignoreUnique ) {
                                         // bottom out at unique expression.
@@ -402 +358 @@
         } // namespace
 
-        bool maybeImpure( const Expression * expr ) {
+        bool maybeImpure( Expression * expr ) {
                 PassVisitor<ImpurityDetector> detector( false );
                 expr->accept( detector );
@@ -408 +364 @@
         }
 
-        bool maybeImpureIgnoreUnique( const Expression * expr ) {
+        bool maybeImpureIgnoreUnique( Expression * expr ) {
                 PassVisitor<ImpurityDetector> detector( true );
                 expr->accept( detector );