Changeset b067d9b for src/Tuples/TupleExpansion.cc

Timestamp:

Oct 29, 2019, 4:01:24 PM (6 years ago)

Author:

Thierry Delisle <tdelisle@…>

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:

773db65, 9421f3d8

Parents:

7951100 (diff), 8364209 (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

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 : Peter A. Buhr
-// Last Modified On : Wed Jun 21 17:35:04 2017
-// Update Count     : 19
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Jul 19 14:39:00 2019
+// Update Count     : 22
 //
 
@@ -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
@@ -58 +63 @@
                 };
 
-                struct TupleTypeReplacer : public WithDeclsToAdd, public WithGuards, public WithTypeSubstitution {
+                struct TupleTypeReplacer : public WithDeclsToAdd, public WithGuards, public WithConstTypeSubstitution {
                         Type * postmutate( TupleType * tupleType );
 
@@ -299 +304 @@
                 // produce the TupleType which aggregates the types of the exprs
                 std::list< Type * > types;
-                Type::Qualifiers qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Lvalue | Type::Atomic | Type::Mutex );
+                Type::Qualifiers qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Atomic | Type::Mutex );
                 for ( Expression * expr : exprs ) {
                         assert( expr->get_result() );
@@ -314 +319 @@
                 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 ) {
@@ -324 +350 @@
         }
 
+        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
@@ -329 +373 @@
                         ImpurityDetector( bool ignoreUnique ) : ignoreUnique( ignoreUnique ) {}
 
-                        void previsit( ApplicationExpr * appExpr ) {
+                        void previsit( const ApplicationExpr * appExpr ) {
                                 visit_children = false;
-                                if ( DeclarationWithType * function = InitTweak::getFunction( appExpr ) ) {
-                                        if ( function->get_linkage() == LinkageSpec::Intrinsic ) {
-                                                if ( function->get_name() == "*?" || function->get_name() == "?[?]" ) {
+                                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;
@@ -342 +386 @@
                                 maybeImpure = true;
                         }
-                        void previsit( UntypedExpr * ) { maybeImpure = true; visit_children = false; }
-                        void previsit( UniqueExpr * ) {
+                        void previsit( const UntypedExpr * ) { maybeImpure = true; visit_children = false; }
+                        void previsit( const UniqueExpr * ) {
                                 if ( ignoreUnique ) {
                                         // bottom out at unique expression.
@@ -358 +402 @@
         } // namespace
 
-        bool maybeImpure( Expression * expr ) {
+        bool maybeImpure( const Expression * expr ) {
                 PassVisitor<ImpurityDetector> detector( false );
                 expr->accept( detector );
@@ -364 +408 @@
         }
 
-        bool maybeImpureIgnoreUnique( Expression * expr ) {
+        bool maybeImpureIgnoreUnique( const Expression * expr ) {
                 PassVisitor<ImpurityDetector> detector( true );
                 expr->accept( detector );