Changeset ac1ed49 for src/ResolvExpr

Timestamp:

Feb 25, 2016, 5:14:15 PM (9 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, ctor, deferred_resn, demangler, enum, forall-pointer-decay, gc_noraii, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, string, with_gc

Children:

33e6a2cc, 90c3b1c, c14cff1

Parents:

41a2620 (diff), 44b7088 (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:/u/cforall/software/cfa/cfa-cc

Location:

src/ResolvExpr

Files:

• AdjustExprType.cc (modified) (2 diffs)
• AlternativeFinder.cc (modified) (1 diff)
• CommonType.cc (modified) (2 diffs)
• ConversionCost.cc (modified) (1 diff)
• ConversionCost.h (modified) (1 diff)
• PtrsAssignable.cc (modified) (2 diffs)
• PtrsCastable.cc (modified) (2 diffs)
• RenameVars.cc (modified) (1 diff)
• RenameVars.h (modified) (1 diff)
• TypeMap.h (added)
• Unify.cc (modified) (2 diffs)

src/ResolvExpr/AdjustExprType.cc ¶

@@ -36 +36 @@
                 virtual Type* mutate( TypeInstType *aggregateUseType );
                 virtual Type* mutate( TupleType *tupleType );
+                virtual Type* mutate( VarArgsType *varArgsType );
 
                 const TypeEnvironment &env;
@@ -111 +112 @@
                 return tupleType;
         }
+
+        Type *AdjustExprType::mutate( VarArgsType *varArgsType ) {
+                return varArgsType;
+        }
 } // namespace ResolvExpr
 

src/ResolvExpr/AlternativeFinder.cc ¶

@@ -572 +572 @@
 
                 AltList candidates;
+                SemanticError errors;
 
                 for ( AltList::const_iterator func = funcFinder.alternatives.begin(); func != funcFinder.alternatives.end(); ++func ) {
-                        PRINT(
-                                std::cerr << "working on alternative: " << std::endl;
-                                func->print( std::cerr, 8 );
-                        )
-                        // check if the type is pointer to function
-                        PointerType *pointer;
-                        if ( func->expr->get_results().size() == 1 && ( pointer = dynamic_cast< PointerType* >( func->expr->get_results().front() ) ) ) {
-                                if ( FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() ) ) {
-                                        for ( std::list< AltList >::iterator actualAlt = possibilities.begin(); actualAlt != possibilities.end(); ++actualAlt ) {
-                                                // XXX
-                                                //Designators::check_alternative( function, *actualAlt );
-                                                makeFunctionAlternatives( *func, function, *actualAlt, std::back_inserter( candidates ) );
-                                        }
-                                } else if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( pointer->get_base() ) ) {
-                                        EqvClass eqvClass;
-                                        if ( func->env.lookup( typeInst->get_name(), eqvClass ) && eqvClass.type ) {
-                                                if ( FunctionType *function = dynamic_cast< FunctionType* >( eqvClass.type ) ) {
-                                                        for ( std::list< AltList >::iterator actualAlt = possibilities.begin(); actualAlt != possibilities.end(); ++actualAlt ) {
-                                                                makeFunctionAlternatives( *func, function, *actualAlt, std::back_inserter( candidates ) );
-                                                        } // for
+                        try {
+                                PRINT(
+                                        std::cerr << "working on alternative: " << std::endl;
+                                        func->print( std::cerr, 8 );
+                                )
+                                // check if the type is pointer to function
+                                PointerType *pointer;
+                                if ( func->expr->get_results().size() == 1 && ( pointer = dynamic_cast< PointerType* >( func->expr->get_results().front() ) ) ) {
+                                        if ( FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() ) ) {
+                                                for ( std::list< AltList >::iterator actualAlt = possibilities.begin(); actualAlt != possibilities.end(); ++actualAlt ) {
+                                                        // XXX
+                                                        //Designators::check_alternative( function, *actualAlt );
+                                                        makeFunctionAlternatives( *func, function, *actualAlt, std::back_inserter( candidates ) );
+                                                }
+                                        } else if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( pointer->get_base() ) ) {
+                                                EqvClass eqvClass;
+                                                if ( func->env.lookup( typeInst->get_name(), eqvClass ) && eqvClass.type ) {
+                                                        if ( FunctionType *function = dynamic_cast< FunctionType* >( eqvClass.type ) ) {
+                                                                for ( std::list< AltList >::iterator actualAlt = possibilities.begin(); actualAlt != possibilities.end(); ++actualAlt ) {
+                                                                        makeFunctionAlternatives( *func, function, *actualAlt, std::back_inserter( candidates ) );
+                                                                } // for
+                                                        } // if
                                                 } // if
                                         } // if
+                                } else {
+                                        // seek a function operator that's compatible
+                                        if ( ! doneInit ) {
+                                                doneInit = true;
+                                                NameExpr *opExpr = new NameExpr( "?()" );
+                                                try {
+                                                        funcOpFinder.findWithAdjustment( opExpr );
+                                                } catch( SemanticError &e ) {
+                                                        // it's ok if there aren't any defined function ops
+                                                }
+                                                PRINT(
+                                                        std::cerr << "known function ops:" << std::endl;
+                                                        printAlts( funcOpFinder.alternatives, std::cerr, 8 );
+                                                )
+                                        }
+
+                                        for ( AltList::const_iterator funcOp = funcOpFinder.alternatives.begin(); funcOp != funcOpFinder.alternatives.end(); ++funcOp ) {
+                                                // check if the type is pointer to function
+                                                PointerType *pointer;
+                                                if ( funcOp->expr->get_results().size() == 1
+                                                        && ( pointer = dynamic_cast< PointerType* >( funcOp->expr->get_results().front() ) ) ) {
+                                                        if ( FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() ) ) {
+                                                                for ( std::list< AltList >::iterator actualAlt = possibilities.begin(); actualAlt != possibilities.end(); ++actualAlt ) {
+                                                                        AltList currentAlt;
+                                                                        currentAlt.push_back( *func );
+                                                                        currentAlt.insert( currentAlt.end(), actualAlt->begin(), actualAlt->end() );
+                                                                        makeFunctionAlternatives( *funcOp, function, currentAlt, std::back_inserter( candidates ) );
+                                                                } // for
+                                                        } // if
+                                                } // if
+                                        } // for
                                 } // if
-                        } else {
-                                // seek a function operator that's compatible
-                                if ( ! doneInit ) {
-                                        doneInit = true;
-                                        NameExpr *opExpr = new NameExpr( "?()" );
-                                        try {
-                                                funcOpFinder.findWithAdjustment( opExpr );
-                                        } catch( SemanticError &e ) {
-                                                // it's ok if there aren't any defined function ops
-                                        }
-                                        PRINT(
-                                                std::cerr << "known function ops:" << std::endl;
-                                                printAlts( funcOpFinder.alternatives, std::cerr, 8 );
-                                        )
-                                }
-
-                                for ( AltList::const_iterator funcOp = funcOpFinder.alternatives.begin(); funcOp != funcOpFinder.alternatives.end(); ++funcOp ) {
-                                        // check if the type is pointer to function
-                                        PointerType *pointer;
-                                        if ( funcOp->expr->get_results().size() == 1
-                                                 && ( pointer = dynamic_cast< PointerType* >( funcOp->expr->get_results().front() ) ) ) {
-                                                if ( FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() ) ) {
-                                                        for ( std::list< AltList >::iterator actualAlt = possibilities.begin(); actualAlt != possibilities.end(); ++actualAlt ) {
-                                                                AltList currentAlt;
-                                                                currentAlt.push_back( *func );
-                                                                currentAlt.insert( currentAlt.end(), actualAlt->begin(), actualAlt->end() );
-                                                                makeFunctionAlternatives( *funcOp, function, currentAlt, std::back_inserter( candidates ) );
-                                                        } // for
-                                                } // if
-                                        } // if
-                                } // for
-                        } // if
-                } // for
+                        } catch ( SemanticError &e ) {
+                                errors.append( e );
+                        }
+                } // for
+
+                // Implement SFINAE; resolution errors are only errors if there aren't any non-erroneous resolutions
+                if ( candidates.empty() && ! errors.isEmpty() ) { throw errors; }
 
                 for ( AltList::iterator withFunc = candidates.begin(); withFunc != candidates.end(); ++withFunc ) {

src/ResolvExpr/CommonType.cc ¶

@@ -38 +38 @@
                 virtual void visit( TypeInstType *aggregateUseType );
                 virtual void visit( TupleType *tupleType );
+                virtual void visit( VarArgsType *varArgsType );
 
                 template< typename RefType > void handleRefType( RefType *inst, Type *other );
@@ -213 +214 @@
         void CommonType::visit( TupleType *tupleType ) {
         }
+
+        void CommonType::visit( VarArgsType *varArgsType ) {
+        }
 } // namespace ResolvExpr
 

src/ResolvExpr/ConversionCost.cc ¶

@@ -247 +247 @@
                 } // if
         }
+
+        void ConversionCost::visit(VarArgsType *varArgsType) {
+                if ( VarArgsType *destAsVarArgs = dynamic_cast< VarArgsType* >( dest ) ) {
+                        cost = Cost::zero;
+                }
+        }
 } // namespace ResolvExpr
 

src/ResolvExpr/ConversionCost.h ¶

@@ -40 +40 @@
                 virtual void visit(TypeInstType *aggregateUseType);
                 virtual void visit(TupleType *tupleType);
+                virtual void visit(VarArgsType *varArgsType);
           protected:
                 Type *dest;

src/ResolvExpr/PtrsAssignable.cc ¶

@@ -38 +38 @@
                 virtual void visit( TypeInstType *inst );
                 virtual void visit( TupleType *tupleType );
+                virtual void visit( VarArgsType *varArgsType );
           private:
                 Type *dest;
@@ -137 +138 @@
 ///   }
         }
+
+        void PtrsAssignable::visit( VarArgsType *varArgsType ) {
+        }
 } // namespace ResolvExpr
 

src/ResolvExpr/PtrsCastable.cc ¶

@@ -39 +39 @@
                 virtual void visit(TypeInstType *inst);
                 virtual void visit(TupleType *tupleType);
+                virtual void visit(VarArgsType *varArgsType);
           private:
                 Type *dest;
@@ -139 +140 @@
                 result = objectCast( dest, env, indexer );
         }
+
+        void PtrsCastable::visit(VarArgsType *varArgsType) {
+                result = objectCast( dest, env, indexer );
+        }
 } // namespace ResolvExpr
 

src/ResolvExpr/RenameVars.cc ¶

@@ -113 +113 @@
         }
 
+        void RenameVars::visit( VarArgsType *varArgsType ) {
+                typeBefore( varArgsType );
+                typeAfter( varArgsType );
+        }
+
         void RenameVars::typeBefore( Type *type ) {
                 if ( ! type->get_forall().empty() ) {

src/ResolvExpr/RenameVars.h ¶

@@ -43 +43 @@
                 virtual void visit( TypeInstType *aggregateUseType );
                 virtual void visit( TupleType *tupleType );
+                virtual void visit( VarArgsType *varArgsType );
 
                 void typeBefore( Type *type );

src/ResolvExpr/Unify.cc ¶

@@ -59 +59 @@
                 virtual void visit(TypeInstType *aggregateUseType);
                 virtual void visit(TupleType *tupleType);
+                virtual void visit(VarArgsType *varArgsType);
 
                 template< typename RefType > void handleRefType( RefType *inst, Type *other );
@@ -583 +584 @@
         }
 
+        void Unify::visit(VarArgsType *varArgsType) {
+                result = dynamic_cast< VarArgsType* >( type2 );
+        }
+
 } // namespace ResolvExpr