Changes in src/ResolvExpr/SpecCost.cc [c6b4432:978e5eb]

File:

• src/ResolvExpr/SpecCost.cc (modified) (1 diff)

src/ResolvExpr/SpecCost.cc

@@ -21 +21 @@
 #include "AST/Pass.hpp"
 #include "AST/Type.hpp"
+#include "Common/PassVisitor.h"
+#include "SynTree/Declaration.h"
+#include "SynTree/Expression.h"
+#include "SynTree/Type.h"
 
 namespace ResolvExpr {
+
+        /// Counts specializations in a type
+        class CountSpecs : public WithShortCircuiting, public WithVisitorRef<CountSpecs> {
+                int count = -1;  ///< specialization count (-1 for none)
+
+        public:
+                int get_count() const { return count >= 0 ? count : 0; }
+
+                // mark specialization of base type
+                void postvisit(PointerType*) { if ( count >= 0 ) ++count; }
+
+                // mark specialization of base type
+                void postvisit(ArrayType*) { if ( count >= 0 ) ++count; }
+
+                // mark specialization of base type
+                void postvisit(ReferenceType*) { if ( count >= 0 ) ++count; }
+
+                void postvisit(StructInstType*) { if ( count >= 0 ) ++count; }
+                void postvisit(UnionInstType*) { if ( count >= 0 ) ++count; }
+
+        private:
+                // takes minimum non-negative count over parameter/return list
+                void takeminover( int& mincount, std::list<DeclarationWithType*>& dwts ) {
+                        for ( DeclarationWithType* dwt : dwts ) {
+                                count = -1;
+                                maybeAccept( dwt->get_type(), *visitor );
+                                if ( count != -1 && count < mincount ) mincount = count;
+                        }
+                }
+
+        public:
+                // take minimal specialization value over ->returnVals and ->parameters
+                void previsit(FunctionType* fty) {
+                        int mincount = std::numeric_limits<int>::max();
+                        takeminover( mincount, fty->parameters );
+                        takeminover( mincount, fty->returnVals );
+                        // add another level to mincount if set
+                        count = mincount < std::numeric_limits<int>::max() ? mincount + 1 : -1;
+                        // already visited children
+                        visit_children = false;
+                }
+
+        private:
+                // returns minimum non-negative count + 1 over type parameters (-1 if none such)
+                int minover( std::list<Expression*>& parms ) {
+                        int mincount = std::numeric_limits<int>::max();
+                        for ( Expression* parm : parms ) {
+                                count = -1;
+                                maybeAccept( parm->result, *visitor );
+                                if ( count != -1 && count < mincount ) mincount = count;
+                        }
+                        return mincount < std::numeric_limits<int>::max() ? mincount + 1 : -1;
+                }
+
+        public:
+                // look for polymorphic parameters
+                void previsit(StructInstType* sty) {
+                        count = minover( sty->parameters );
+                }
+
+                // look for polymorphic parameters
+                void previsit(UnionInstType* uty) {
+                        count = minover( uty->parameters );
+                }
+
+                // note polymorphic type (which may be specialized)
+                // xxx - maybe account for open/closed type variables
+                void postvisit(TypeInstType*) { count = 0; }
+
+                // take minimal specialization over elements
+                // xxx - maybe don't increment, tuple flattening doesn't necessarily specialize
+                void previsit(TupleType* tty) {
+                        int mincount = std::numeric_limits<int>::max();
+                        for ( Type* ty : tty->types ) {
+                                count = -1;
+                                maybeAccept( ty, *visitor );
+                                if ( count != -1 && count < mincount ) mincount = count;
+                        }
+                        count = mincount < std::numeric_limits<int>::max() ? mincount + 1 : -1;
+                        visit_children = false;
+                }
+        };
+
+        /// Returns the (negated) specialization cost for a given type
+        int specCost( Type* ty ) {
+                PassVisitor<CountSpecs> counter;
+                maybeAccept( ty, *counter.pass.visitor );
+                return counter.pass.get_count();
+        }
 
 namespace {