Changeset 2908f08 for src/ResolvExpr/SpecCost.cc

Timestamp:

Nov 17, 2023, 3:03:51 PM (10 months ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

master

Children:

f7f997a

Parents:

41606df1

Message:

Most of ResolvExpr? was written before the new style standard. Some files updated, focus on headers.

File:

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

src/ResolvExpr/SpecCost.cc

@@ -33 +33 @@
 }
 
-        /// The specialization counter inner class.
-        class SpecCounter : public ast::WithShortCircuiting, public ast::WithVisitorRef<SpecCounter> {
-                int count = -1;  ///< specialization count (-1 for none)
+/// The specialization counter inner class.
+class SpecCounter : public ast::WithShortCircuiting, public ast::WithVisitorRef<SpecCounter> {
+        int count = -1;  ///< specialization count (-1 for none)
 
-                // Converts the max value to -1 (none), otherwise increments the value.
-                static int toNoneOrInc( int value ) {
-                        assert( 0 <= value );
-                        return value < std::numeric_limits<int>::max() ? value + 1 : -1;
+        // Converts the max value to -1 (none), otherwise increments the value.
+        static int toNoneOrInc( int value ) {
+                assert( 0 <= value );
+                return value < std::numeric_limits<int>::max() ? value + 1 : -1;
+        }
+
+        template<typename T> using MapperT =
+                typename std::add_pointer<ast::Type const *(typename T::value_type const &)>::type;
+
+        // Update the minimum to the new lowest non-none value.
+        template<typename T>
+        void updateMinimumPresent( int & minimum, const T & list, MapperT<T> mapper ) {
+                for ( const auto & node : list ) {
+                        count = -1;
+
+                        if ( ast::Type const * type = mapper( node ) ) {
+                                ast::Type const * newType = type->accept( *visitor );
+                                assert( newType == nullptr || newType == type );
+                        }
+
+                        if ( count != -1 && count < minimum ) minimum = count;
                 }
+        }
 
-                template<typename T> using MapperT =
-                        typename std::add_pointer<ast::Type const *(typename T::value_type const &)>::type;
+        // Returns minimum non-negative count + 1 over type parameters (-1 if none such).
+        template<typename T>
+        int minimumPresent( const T & list, MapperT<T> mapper ) {
+                int minCount = std::numeric_limits<int>::max();
+                updateMinimumPresent( minCount, list, mapper );
+                return toNoneOrInc( minCount );
+        }
 
-                // Update the minimum to the new lowest non-none value.
-                template<typename T>
-                void updateMinimumPresent( int & minimum, const T & list, MapperT<T> mapper ) {
-                        for ( const auto & node : list ) {
-                                count = -1;
+public:
+        int result() const { return 0 <= count ? count : 0; }
 
-                                if ( ast::Type const * type = mapper( node ) ) {
-                                        ast::Type const * newType = type->accept( *visitor );
-                                        assert( newType == nullptr || newType == type );
-                                }
+        // Mark specialization of base type.
+        void postvisit( const ast::PointerType * ) { if ( 0 <= count ) ++count; }
+        void postvisit( const ast::ArrayType * ) { if ( 0 <= count ) ++count; }
+        void postvisit( const ast::ReferenceType * ) { if ( 0 <= count ) ++count; }
 
-                                if ( count != -1 && count < minimum ) minimum = count;
-                        }
-                }
+        void postvisit( const ast::StructInstType * ) { if ( 0 <= count ) ++count; }
+        void postvisit( const ast::UnionInstType * ) { if ( 0 <= count ) ++count; }
 
-                // Returns minimum non-negative count + 1 over type parameters (-1 if none such).
-                template<typename T>
-                int minimumPresent( const T & list, MapperT<T> mapper ) {
-                        int minCount = std::numeric_limits<int>::max();
-                        updateMinimumPresent( minCount, list, mapper );
-                        return toNoneOrInc( minCount );
-                }
+        // Use the minimal specialization value over returns and params.
+        void previsit( const ast::FunctionType * fty ) {
+                int minCount = std::numeric_limits<int>::max();
+                updateMinimumPresent( minCount, fty->params, type_deref );
+                updateMinimumPresent( minCount, fty->returns, type_deref );
+                // Add another level to minCount if set.
+                count = toNoneOrInc( minCount );
+                // We have already visited children.
+                visit_children = false;
+        }
 
-        public:
-                int result() const { return 0 <= count ? count : 0; }
+        // Look for polymorphic parameters.
+        void previsit( const ast::StructInstType * sty ) {
+                count = minimumPresent( sty->params, expr_result );
+        }
 
-                // Mark specialization of base type.
-                void postvisit( const ast::PointerType * ) { if ( count >= 0 ) ++count; }
-                void postvisit( const ast::ArrayType * ) { if ( count >= 0 ) ++count; }
-                void postvisit( const ast::ReferenceType * ) { if ( count >= 0 ) ++count; }
+        // Look for polymorphic parameters.
+        void previsit( const ast::UnionInstType * uty ) {
+                count = minimumPresent( uty->params, expr_result );
+        }
 
-                void postvisit( const ast::StructInstType * ) { if ( count >= 0 ) ++count; }
-                void postvisit( const ast::UnionInstType * ) { if ( count >= 0 ) ++count; }
+        // Note polymorphic type (which may be specialized).
+        // xxx - maybe account for open/closed type variables
+        void postvisit( const ast::TypeInstType * ) { count = 0; }
 
-                // Use the minimal specialization value over returns and params.
-                void previsit( const ast::FunctionType * fty ) {
-                        int minCount = std::numeric_limits<int>::max();
-                        updateMinimumPresent( minCount, fty->params, type_deref );
-                        updateMinimumPresent( minCount, fty->returns, type_deref );
-                        // Add another level to minCount if set.
-                        count = toNoneOrInc( minCount );
-                        // We have already visited children.
-                        visit_children = false;
-                }
-
-                // Look for polymorphic parameters.
-                void previsit( const ast::StructInstType * sty ) {
-                        count = minimumPresent( sty->params, expr_result );
-                }
-
-                // Look for polymorphic parameters.
-                void previsit( const ast::UnionInstType * uty ) {
-                        count = minimumPresent( uty->params, expr_result );
-                }
-
-                // Note polymorphic type (which may be specialized).
-                // xxx - maybe account for open/closed type variables
-                void postvisit( const ast::TypeInstType * ) { count = 0; }
-
-                // Use the minimal specialization over elements.
-                // xxx - maybe don't increment, tuple flattening doesn't necessarily specialize
-                void previsit( const ast::TupleType * tty ) {
-                        count = minimumPresent( tty->types, type_deref );
-                        visit_children = false;
-                }
-        };
+        // Use the minimal specialization over elements.
+        // xxx - maybe don't increment, tuple flattening doesn't necessarily specialize
+        void previsit( const ast::TupleType * tty ) {
+                count = minimumPresent( tty->types, type_deref );
+                visit_children = false;
+        }
+};
 
 } // namespace