Changes in / [cce7872:52f85e0]

Location:

src

Files:

• GenPoly/Box.cc (modified) (3 diffs)
• SymTab/Validate.cc (modified) (5 diffs)

src/GenPoly/Box.cc

@@ -992 +992 @@
                 }
 
-                /// Wraps a function declaration in a new pointer-to-function variable expression
-                VariableExpr *wrapFunctionDecl( DeclarationWithType *functionDecl ) {
-                        // line below cloned from FixFunction.cc
-                        ObjectDecl *functionObj = new ObjectDecl( functionDecl->get_name(), functionDecl->get_storageClass(), functionDecl->get_linkage(), 0,
-                                                                  new PointerType( Type::Qualifiers(), functionDecl->get_type()->clone() ), 0 );
-                        functionObj->set_mangleName( functionDecl->get_mangleName() );
-                        return new VariableExpr( functionObj );
-                }
-                
                 Statement * Pass1::mutate( ReturnStmt *returnStmt ) {
                         if ( retval && returnStmt->get_expr() ) {
@@ -1016 +1007 @@
 
                                 // find assignment operator for (polymorphic) return type
-                                ApplicationExpr *assignExpr = 0;
+                                DeclarationWithType *assignDecl = 0;
                                 if ( TypeInstType *typeInst = dynamic_cast< TypeInstType *>( retval->get_type() ) ) {
-                                        // find assignment operator for type variable
                                         std::map< std::string, DeclarationWithType *>::const_iterator assignIter = assignOps.find( typeInst->get_name() );
                                         if ( assignIter == assignOps.end() ) {
                                                 throw SemanticError( "Attempt to return dtype or ftype object in ", returnStmt->get_expr() );
                                         } // if
-                                        assignExpr = new ApplicationExpr( new VariableExpr( assignIter->second ) );
+                                        assignDecl = assignIter->second;
                                 } else if ( ReferenceToType *refType = dynamic_cast< ReferenceToType *>( retval->get_type() ) ) {
-                                        // find assignment operator for generic type
                                         ScopedMap< std::string, DeclarationWithType *>::const_iterator assignIter = scopedAssignOps.find( refType->get_name() );
                                         if ( assignIter == scopedAssignOps.end() ) {
                                                 throw SemanticError( "Attempt to return dtype or ftype generic object in ", returnStmt->get_expr() );
                                         }
-
-                                        // wrap it up in an application expression
                                         DeclarationWithType *functionDecl = assignIter->second;
-                                        assignExpr = new ApplicationExpr( wrapFunctionDecl( functionDecl ) );
-                                        assignExpr->set_env( env->clone() );
-
-                                        // find each of its needed secondary assignment operators
-                                        std::list< Expression* > &tyParams = refType->get_parameters();
-                                        std::list< TypeDecl* > &forallParams = functionDecl->get_type()->get_forall();
-                                        std::list< Expression* >::const_iterator tyIt = tyParams.begin();
-                                        std::list< TypeDecl* >::const_iterator forallIt = forallParams.begin();
-                                        for ( ; tyIt != tyParams.end() && forallIt != forallParams.end(); ++tyIt, ++forallIt ) {
-                                                if ( (*forallIt)->get_kind() != TypeDecl::Any ) continue; // skip types with no assign op (ftype/dtype)
-
-                                                std::list< DeclarationWithType* > &asserts = (*forallIt)->get_assertions();
-                                                assert( ! asserts.empty() && "Type param needs assignment operator assertion" );
-                                                DeclarationWithType *actualDecl = asserts.front();
-                                                ReferenceToType *actualType = isAssignment( actualDecl );
-                                                assert( actualType && "First assertion of type with assertions should be assignment operator" );
-                                                TypeExpr *formalTypeExpr = dynamic_cast< TypeExpr* >( *tyIt );
-                                                assert( formalTypeExpr && "type parameters must be type expressions" );
-                                                Type *formalType = formalTypeExpr->get_type();
-                                                assignExpr->get_env()->add( actualType->get_name(), formalType );
-                                                
-                                                DeclarationWithType *assertAssign = 0;
-                                                if ( TypeInstType *formalTypeInstType = dynamic_cast< TypeInstType* >( formalType ) ) {
-                                                        std::map< std::string, DeclarationWithType *>::const_iterator assertAssignIt = assignOps.find( formalTypeInstType->get_name() );
-                                                        if ( assertAssignIt == assignOps.end() ) {
-                                                                throw SemanticError( "No assignment operation found for ", formalTypeInstType );
-                                                        }
-                                                        assertAssign = assertAssignIt->second;
-                                                        //assignExpr->get_env()->add( formalTypeInstType->get_name(), actualType );
-                                                } else if ( ReferenceToType *formalReferenceType = dynamic_cast< ReferenceToType* >( formalType ) )  {
-                                                        ScopedMap< std::string, DeclarationWithType *>::const_iterator assertAssignIt = scopedAssignOps.find( formalReferenceType->get_name() );
-                                                        if ( assertAssignIt == scopedAssignOps.end() ) {
-                                                                throw SemanticError( "No assignment operation found for ", formalReferenceType );
-                                                        }
-                                                        assertAssign = assertAssignIt->second;
-                                                } else assert( false && "returning polymorphic types with non struct/polymorphic parameters not yet supported" );
-                                                
-
-                                                assignExpr->get_inferParams()[ actualDecl->get_uniqueId() ]
-                                                        = ParamEntry( assertAssign->get_uniqueId(), assertAssign->get_type()->clone(), actualDecl->get_type()->clone(), wrapFunctionDecl( assertAssign ) );
-                                        }
+                                        // line below cloned from FixFunction.cc
+                                        assignDecl = new ObjectDecl( functionDecl->get_name(), functionDecl->get_storageClass(), functionDecl->get_linkage(), 0,
+                                                                     new PointerType( Type::Qualifiers(), functionDecl->get_type()->clone() ), 0 );
+                                        assignDecl->set_mangleName( functionDecl->get_mangleName() );
                                 }
-                                assert( assignExpr );
+                                assert( assignDecl );
 
                                 // replace return statement with appropriate assignment to out parameter
+                                ApplicationExpr *assignExpr = new ApplicationExpr( new VariableExpr( assignDecl ) );
                                 Expression *retParm = new NameExpr( retval->get_name() );
                                 retParm->get_results().push_back( new PointerType( Type::Qualifiers(), retval->get_type()->clone() ) );
@@ -1402 +1353 @@
                                 delete memberExpr;
                                 return fieldLoc;
-                        } else if ( dynamic_cast< UnionInstType* >( objectType ) ) {
+                        } else if ( UnionInstType *unionType = dynamic_cast< UnionInstType* >( objectType ) ) {
                                 // union members are all at offset zero, so build appropriately-dereferenced variable
                                 Expression *derefdVar = makeDerefdVar( varExpr->clone(), varDepth );

src/SymTab/Validate.cc

@@ -382 +382 @@
                 // it's not a semantic error if the struct is not found, just an implicit forward declaration
                 if ( st ) {
-                        //assert( ! structInst->get_baseStruct() || structInst->get_baseStruct()->get_members().empty() || ! st->get_members().empty() );
+                        assert( ! structInst->get_baseStruct() || structInst->get_baseStruct()->get_members().empty() || ! st->get_members().empty() );
                         structInst->set_baseStruct( st );
                 } // if
@@ -659 +659 @@
         }
 
-        /// Creates a new type decl that's the same as src, but renamed and with only the ?=? assertion (for complete types only)
-        TypeDecl *cloneAndRename( TypeDecl *src, const std::string &name ) {
-                TypeDecl *dst = new TypeDecl( name, src->get_storageClass(), 0, src->get_kind() );
-
-                if ( src->get_kind() == TypeDecl::Any ) {
-                        // just include assignment operator assertion
-                        TypeInstType *assignParamType = new TypeInstType( Type::Qualifiers(), name, dst );
-                        FunctionType *assignFunctionType = new FunctionType( Type::Qualifiers(), false );
-                        assignFunctionType->get_returnVals().push_back(
-                                new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, assignParamType->clone(), 0 ) );
-                        assignFunctionType->get_parameters().push_back(
-                                new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), assignParamType->clone() ), 0 ) );
-                        assignFunctionType->get_parameters().push_back(
-                                new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, assignParamType, 0 ) );
-                        FunctionDecl *assignAssert = new FunctionDecl( "?=?", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, assignFunctionType, 0, false, false );
-                        dst->get_assertions().push_back( assignAssert );
-                }
-
-                return dst;
-        }
-
         Declaration *makeStructAssignment( StructDecl *aggregateDecl, StructInstType *refType, unsigned int functionNesting ) {
                 FunctionType *assignType = new FunctionType( Type::Qualifiers(), false );
@@ -687 +666 @@
                 std::list< TypeDecl* >& genericParams = aggregateDecl->get_parameters();
                 std::list< Expression* > structParams;  // List of matching parameters to put on types
-                TypeSubstitution genericSubs; // Substitutions to make to member types of struct
                 for ( std::list< TypeDecl* >::const_iterator param = genericParams.begin(); param != genericParams.end(); ++param ) {
                         isGeneric = true;
-                        TypeDecl *typeParam = cloneAndRename( *param, "_autoassign_" + aggregateDecl->get_name() + "_" + (*param)->get_name() );
+                        TypeDecl *typeParam = (*param)->clone();
                         assignType->get_forall().push_back( typeParam );
-                        TypeInstType *newParamType = new TypeInstType( Type::Qualifiers(), typeParam->get_name(), typeParam );
-                        genericSubs.add( (*param)->get_name(), newParamType );
-                        structParams.push_back( new TypeExpr( newParamType ) );
+                        structParams.push_back( new TypeExpr( new TypeInstType( Type::Qualifiers(), typeParam->get_name(), typeParam ) ) );
                 }
 
@@ -725 +701 @@
                                 }
 
-                                if ( isGeneric ) {
-                                        // rewrite member type in terms of the type variables on this operator
-                                        DeclarationWithType *fixedMember = dwt->clone();
-                                        genericSubs.apply( fixedMember );
-
-                                        // assign to both destination and return value
-                                        if ( ArrayType *array = dynamic_cast< ArrayType * >( fixedMember->get_type() ) ) {
-                                                makeArrayAssignment( srcParam, dstParam, fixedMember, array, back_inserter( assignDecl->get_statements()->get_kids() ) );
-                                                makeArrayAssignment( srcParam, returnVal, fixedMember, array, back_inserter( assignDecl->get_statements()->get_kids() ) );
-                                        } else {
-                                                makeScalarAssignment( srcParam, dstParam, fixedMember, back_inserter( assignDecl->get_statements()->get_kids() ) );
-                                                makeScalarAssignment( srcParam, returnVal, fixedMember, back_inserter( assignDecl->get_statements()->get_kids() ) );
-                                        } // if
+                                if ( ArrayType *array = dynamic_cast< ArrayType * >( dwt->get_type() ) ) {
+                                        makeArrayAssignment( srcParam, dstParam, dwt, array, back_inserter( assignDecl->get_statements()->get_kids() ) );
+                                        if ( isGeneric ) makeArrayAssignment( srcParam, returnVal, dwt, array, back_inserter( assignDecl->get_statements()->get_kids() ) );
                                 } else {
-                                        // assign to destination
-                                        if ( ArrayType *array = dynamic_cast< ArrayType * >( dwt->get_type() ) ) {
-                                                makeArrayAssignment( srcParam, dstParam, dwt, array, back_inserter( assignDecl->get_statements()->get_kids() ) );
-                                        } else {
-                                                makeScalarAssignment( srcParam, dstParam, dwt, back_inserter( assignDecl->get_statements()->get_kids() ) );
-                                        } // if
+                                        makeScalarAssignment( srcParam, dstParam, dwt, back_inserter( assignDecl->get_statements()->get_kids() ) );
+                                        if ( isGeneric ) makeScalarAssignment( srcParam, returnVal, dwt, back_inserter( assignDecl->get_statements()->get_kids() ) );
                                 } // if
                         } // if
@@ -762 +724 @@
                 for ( std::list< TypeDecl* >::const_iterator param = genericParams.begin(); param != genericParams.end(); ++param ) {
                         isGeneric = true;
-                        TypeDecl *typeParam = cloneAndRename( *param, "_autoassign_" + aggregateDecl->get_name() + "_" + (*param)->get_name() );
+                        TypeDecl *typeParam = (*param)->clone();
                         assignType->get_forall().push_back( typeParam );
                         unionParams.push_back( new TypeExpr( new TypeInstType( Type::Qualifiers(), typeParam->get_name(), typeParam ) ) );