Changeset 4c8621ac for src/Tuples

Timestamp:

Dec 22, 2016, 4:07:58 PM (7 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, resolv-new, with_gc

Children:

1e3d5b6

Parents:

907eccb

Message:

allow construction, destruction, and assignment for empty tuples, allow matching a ttype parameter with an empty tuple, fix specialization to work with empty tuples and void functions

Location:

src/Tuples

Files:

• TupleAssignment.cc (modified) (4 diffs)
• TupleExpansion.cc (modified) (1 diff)

src/Tuples/TupleAssignment.cc

@@ -42 +42 @@
           private:
                 void match();
+                void handleEmptyTuple( const ResolvExpr::AltList & alts );
 
                 struct Matcher {
@@ -130 +131 @@
                                                 }
                                                 match();
+                                        } else {
+                                                // handle empty case specially. It is easy to cause conflicts for tuple assignment when we consider any expression with Tuple type to be a tuple.
+                                                // Instead, only tuple expressions and expressions with at least 2 results are considered tuples for tuple assignment. This most obviously leaves out the
+                                                // nullary and unary cases. The unary case is handled nicely by the alternative finder as is. For example, an expression of type [int] will be exploded
+                                                // into a list of one element (combined with the RHS elements), which will easily allow for intrinsic construction. This seems like a best case scenario anyway,
+                                                // since intrinsic construction is much simpler from a code-gen perspective than tuple construction is.
+                                                // This leaves the empty case, which is not easily handled by existing alternative finder logic. Instead, it seems simple enough to hanlde here that if the left
+                                                // side is an empty tuple, then the right side is allowed to be either an empty tuple or an empty list. Fortunately, these cases are identical when exploded.
+                                                handleEmptyTuple( *ali );
                                         }
                                 }
@@ -248 +258 @@
                 static UniqueName lhsNamer( "__massassign_L" );
                 static UniqueName rhsNamer( "__massassign_R" );
-                assert ( ! lhs.empty() && rhs.size() <= 1);
+                assert( ! lhs.empty() && rhs.size() <= 1 );
 
                 ObjectDecl * rtmp = rhs.size() == 1 ? newObject( rhsNamer, rhs.front().expr ) : nullptr;
@@ -278 +288 @@
                 }
         }
+
+        // empty case is okay when right side is also "empty" (empty explosion handles no argument case as well as empty tuple case)
+        void TupleAssignSpotter::handleEmptyTuple( const ResolvExpr::AltList & alts ) {
+                assert( ! alts.empty() );
+                Expression * lhs = alts.front().expr;
+                if ( PointerType * ptrType = dynamic_cast< PointerType * >( lhs->get_result() ) ) {
+                        if ( TupleType * tupleType = dynamic_cast< TupleType * >( ptrType->get_base() ) ) {
+                                if ( tupleType->size() == 0 ) {
+                                        ResolvExpr::AltList rhs;
+                                        explode( std::next(alts.begin(), 1), alts.end(), currentFinder.get_indexer(), back_inserter(rhs) );
+                                        if ( rhs.empty() ) {
+                                                // okay, no other case is allowed
+                                                ResolvExpr::TypeEnvironment compositeEnv;
+                                                simpleCombineEnvironments( alts.begin(), alts.end(), compositeEnv );
+                                                currentFinder.get_alternatives().push_front( ResolvExpr::Alternative( new TupleAssignExpr( std::list< Expression * >(), std::list< ObjectDecl * >() ), compositeEnv, ResolvExpr::sumCost( alts ) ) );
+                                        }
+                                }
+                        }
+                }
+        }
 } // namespace Tuples
 

src/Tuples/TupleExpansion.cc

@@ -225 +225 @@
                                 decl->get_parameters().push_back( tyParam );
                         }
+                        if ( tupleType->size() == 0 ) {
+                                // empty structs are not standard C. Add a dummy field to empty tuples to silence warnings when a compound literal Tuple0 is created.
+                                decl->get_members().push_back( new ObjectDecl( "dummy", DeclarationNode::NoStorageClass, LinkageSpec::C, nullptr, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr ) );
+                        }
                         typeMap[mangleName] = decl;
                         addDeclaration( decl );